https://pletox.com/js/vendor/pdfjs/pdf.js

1/**
2 * @licstart The following is the entire license notice for the
3 * JavaScript code in this page
4 *
5 * Copyright 2024 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * JavaScript code in this page
21 */
22
23/**
24 * pdfjsVersion = 5.4.624
25 * pdfjsBuild = 384c6208b
26 */
27/******/ // The require scope
28/******/ var __webpack_require__ = {};
29/******/ 
30/************************************************************************/
31/******/ /* webpack/runtime/define property getters */
32/******/ (() => {
33/******/ 	// define getter functions for harmony exports
34/******/ 	__webpack_require__.d = (exports, definition) => {
35/******/ 		for(var key in definition) {
36/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
37/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
38/******/ 			}
39/******/ 		}
40/******/ 	};
41/******/ })();
42/******/ 
43/******/ /* webpack/runtime/hasOwnProperty shorthand */
44/******/ (() => {
45/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
46/******/ })();
47/******/ 
48/************************************************************************/
49var __webpack_exports__ = {};
50
51;// ./src/shared/util.js
52const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
53const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
54const LINE_FACTOR = 1.35;
55const LINE_DESCENT_FACTOR = 0.35;
56const BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
57const RenderingIntentFlag = {
58  ANY: 0x01,
59  DISPLAY: 0x02,
60  PRINT: 0x04,
61  SAVE: 0x08,
62  ANNOTATIONS_FORMS: 0x10,
63  ANNOTATIONS_STORAGE: 0x20,
64  ANNOTATIONS_DISABLE: 0x40,
65  IS_EDITING: 0x80,
66  OPLIST: 0x100
67};
68const AnnotationMode = {
69  DISABLE: 0,
70  ENABLE: 1,
71  ENABLE_FORMS: 2,
72  ENABLE_STORAGE: 3
73};
74const AnnotationEditorPrefix = "pdfjs_internal_editor_";
75const AnnotationEditorType = {
76  DISABLE: -1,
77  NONE: 0,
78  FREETEXT: 3,
79  HIGHLIGHT: 9,
80  STAMP: 13,
81  INK: 15,
82  POPUP: 16,
83  SIGNATURE: 101,
84  COMMENT: 102
85};
86const AnnotationEditorParamsType = {
87  RESIZE: 1,
88  CREATE: 2,
89  FREETEXT_SIZE: 11,
90  FREETEXT_COLOR: 12,
91  FREETEXT_OPACITY: 13,
92  INK_COLOR: 21,
93  INK_THICKNESS: 22,
94  INK_OPACITY: 23,
95  HIGHLIGHT_COLOR: 31,
96  HIGHLIGHT_THICKNESS: 32,
97  HIGHLIGHT_FREE: 33,
98  HIGHLIGHT_SHOW_ALL: 34,
99  DRAW_STEP: 41
100};
101const PermissionFlag = {
102  PRINT: 0x04,
103  MODIFY_CONTENTS: 0x08,
104  COPY: 0x10,
105  MODIFY_ANNOTATIONS: 0x20,
106  FILL_INTERACTIVE_FORMS: 0x100,
107  COPY_FOR_ACCESSIBILITY: 0x200,
108  ASSEMBLE: 0x400,
109  PRINT_HIGH_QUALITY: 0x800
110};
111const MeshFigureType = {
112  TRIANGLES: 1,
113  LATTICE: 2,
114  PATCH: 3
115};
116const TextRenderingMode = {
117  FILL: 0,
118  STROKE: 1,
119  FILL_STROKE: 2,
120  INVISIBLE: 3,
121  FILL_ADD_TO_PATH: 4,
122  STROKE_ADD_TO_PATH: 5,
123  FILL_STROKE_ADD_TO_PATH: 6,
124  ADD_TO_PATH: 7,
125  FILL_STROKE_MASK: 3,
126  ADD_TO_PATH_FLAG: 4
127};
128const util_ImageKind = {
129  GRAYSCALE_1BPP: 1,
130  RGB_24BPP: 2,
131  RGBA_32BPP: 3
132};
133const AnnotationType = {
134  TEXT: 1,
135  LINK: 2,
136  FREETEXT: 3,
137  LINE: 4,
138  SQUARE: 5,
139  CIRCLE: 6,
140  POLYGON: 7,
141  POLYLINE: 8,
142  HIGHLIGHT: 9,
143  UNDERLINE: 10,
144  SQUIGGLY: 11,
145  STRIKEOUT: 12,
146  STAMP: 13,
147  CARET: 14,
148  INK: 15,
149  POPUP: 16,
150  FILEATTACHMENT: 17,
151  SOUND: 18,
152  MOVIE: 19,
153  WIDGET: 20,
154  SCREEN: 21,
155  PRINTERMARK: 22,
156  TRAPNET: 23,
157  WATERMARK: 24,
158  THREED: 25,
159  REDACT: 26
160};
161const AnnotationReplyType = {
162  GROUP: "Group",
163  REPLY: "R"
164};
165const AnnotationFlag = {
166  INVISIBLE: 0x01,
167  HIDDEN: 0x02,
168  PRINT: 0x04,
169  NOZOOM: 0x08,

254  curveTo3: 17,
255  closePath: 18,
256  rectangle: 19,
257  stroke: 20,
258  closeStroke: 21,
259  fill: 22,
260  eoFill: 23,
261  fillStroke: 24,
262  eoFillStroke: 25,
263  closeFillStroke: 26,
264  closeEOFillStroke: 27,
265  endPath: 28,
266  clip: 29,
267  eoClip: 30,
268  beginText: 31,
269  endText: 32,
270  setCharSpacing: 33,
271  setWordSpacing: 34,
272  setHScale: 35,
273  setLeading: 36,
274  setFont: 37,
275  setTextRenderingMode: 38,
276  setTextRise: 39,
277  moveText: 40,
278  setLeadingMoveText: 41,
279  setTextMatrix: 42,
280  nextLine: 43,
281  showText: 44,
282  showSpacedText: 45,
283  nextLineShowText: 46,
284  nextLineSetSpacingShowText: 47,
285  setCharWidth: 48,
286  setCharWidthAndBounds: 49,
287  setStrokeColorSpace: 50,
288  setFillColorSpace: 51,
289  setStrokeColor: 52,
290  setStrokeColorN: 53,
291  setFillColor: 54,
292  setFillColorN: 55,
293  setStrokeGray: 56,
294  setFillGray: 57,
295  setStrokeRGBColor: 58,
296  setFillRGBColor: 59,
297  setStrokeCMYKColor: 60,
298  setFillCMYKColor: 61,
299  shadingFill: 62,
300  beginInlineImage: 63,
301  beginImageData: 64,
302  endInlineImage: 65,
303  paintXObject: 66,
304  markPoint: 67,
305  markPointProps: 68,
306  beginMarkedContent: 69,
307  beginMarkedContentProps: 70,
308  endMarkedContent: 71,
309  beginCompat: 72,
310  endCompat: 73,
311  paintFormXObjectBegin: 74,
312  paintFormXObjectEnd: 75,
313  beginGroup: 76,
314  endGroup: 77,
315  beginAnnotation: 80,
316  endAnnotation: 81,
317  paintImageMaskXObject: 83,
318  paintImageMaskXObjectGroup: 84,
319  paintImageXObject: 85,
320  paintInlineImageXObject: 86,
321  paintInlineImageXObjectGroup: 87,
322  paintImageXObjectRepeat: 88,
323  paintImageMaskXObjectRepeat: 89,
324  paintSolidColorImageMask: 90,
325  constructPath: 91,
326  setStrokeTransparent: 92,
327  setFillTransparent: 93,
328  rawFillPath: 94
329};
330const DrawOPS = {
331  moveTo: 0,
332  lineTo: 1,
333  curveTo: 2,
334  quadraticCurveTo: 3,
335  closePath: 4
336};
337const PasswordResponses = {
338  NEED_PASSWORD: 1,
339  INCORRECT_PASSWORD: 2
340};
341let verbosity = VerbosityLevel.WARNINGS;
342function setVerbosityLevel(level) {
343  if (Number.isInteger(level)) {
344    verbosity = level;
345  }
346}
347function getVerbosityLevel() {
348  return verbosity;
349}
350function info(msg) {
351  if (verbosity >= VerbosityLevel.INFOS) {
352    console.info(`Info: ${msg}`);
353  }
354}
355function warn(msg) {
356  if (verbosity >= VerbosityLevel.WARNINGS) {
357    console.warn(`Warning: ${msg}`);
358  }
359}
360function unreachable(msg) {
361  throw new Error(msg);
362}
363function assert(cond, msg) {
364  if (!cond) {
365    unreachable(msg);
366  }
367}
368function _isValidProtocol(url) {
369  switch (url?.protocol) {
370    case "http:":
371    case "https:":
372    case "ftp:":
373    case "mailto:":
374    case "tel:":
375      return true;
376    default:
377      return false;
378  }
379}
380function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
381  if (!url) {
382    return null;
383  }
384  if (options && typeof url === "string") {
385    if (options.addDefaultProtocol && url.startsWith("www.")) {
386      const dots = url.match(/\./g);
387      if (dots?.length >= 2) {
388        url = `http://${url}`;
389      }
390    }
391    if (options.tryConvertEncoding) {
392      try {
393        url = stringToUTF8String(url);
394      } catch {}
395    }
396  }
397  const absoluteUrl = baseUrl ? URL.parse(url, baseUrl) : URL.parse(url);
398  return _isValidProtocol(absoluteUrl) ? absoluteUrl : null;
399}
400function updateUrlHash(url, hash, allowRel = false) {
401  const res = URL.parse(url);
402  if (res) {
403    res.hash = hash;
404    return res.href;
405  }
406  if (allowRel && createValidAbsoluteUrl(url, "http://example.com")) {
407    return url.split("#", 1)[0] + `${hash ? `#${hash}` : ""}`;
408  }
409  return "";
410}
411function shadow(obj, prop, value, nonSerializable = false) {
412  Object.defineProperty(obj, prop, {
413    value,
414    enumerable: !nonSerializable,
415    configurable: true,
416    writable: false
417  });
418  return value;
419}
420const BaseException = function BaseExceptionClosure() {
421  function BaseException(message, name) {
422    this.message = message;
423    this.name = name;
424  }
425  BaseException.prototype = new Error();
426  BaseException.constructor = BaseException;
427  return BaseException;
428}();
429class PasswordException extends BaseException {
430  constructor(msg, code) {
431    super(msg, "PasswordException");
432    this.code = code;
433  }
434}
435class UnknownErrorException extends BaseException {
436  constructor(msg, details) {
437    super(msg, "UnknownErrorException");
438    this.details = details;
439  }
440}
441class InvalidPDFException extends BaseException {
442  constructor(msg) {
443    super(msg, "InvalidPDFException");
444  }
445}
446class ResponseException extends BaseException {
447  constructor(msg, status, missing) {
448    super(msg, "ResponseException");
449    this.status = status;
450    this.missing = missing;
451  }
452}
453class FormatError extends BaseException {
454  constructor(msg) {
455    super(msg, "FormatError");
456  }
457}
458class AbortException extends BaseException {
459  constructor(msg) {
460    super(msg, "AbortException");
461  }
462}
463function bytesToString(bytes) {
464  if (typeof bytes !== "object" || bytes?.length === undefined) {
465    unreachable("Invalid argument for bytesToString");
466  }
467  const length = bytes.length;
468  const MAX_ARGUMENT_COUNT = 8192;
469  if (length < MAX_ARGUMENT_COUNT) {
470    return String.fromCharCode.apply(null, bytes);
471  }
472  const strBuf = [];
473  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
474    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
475    const chunk = bytes.subarray(i, chunkEnd);
476    strBuf.push(String.fromCharCode.apply(null, chunk));
477  }
478  return strBuf.join("");
479}
480function stringToBytes(str) {
481  if (typeof str !== "string") {
482    unreachable("Invalid argument for stringToBytes");
483  }
484  const length = str.length;
485  const bytes = new Uint8Array(length);
486  for (let i = 0; i < length; ++i) {
487    bytes[i] = str.charCodeAt(i) & 0xff;

488  }
489  return bytes;
490}
491function string32(value) {
492  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
493}
494function objectSize(obj) {
495  return Object.keys(obj).length;
496}
497function isLittleEndian() {
498  const buffer8 = new Uint8Array(4);
499  buffer8[0] = 1;
500  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
501  return view32[0] === 1;
502}
503function isEvalSupported() {
504  try {
505    new Function("");
506    return true;
507  } catch {
508    return false;
509  }
510}
511class util_FeatureTest {
512  static get isLittleEndian() {
513    return shadow(this, "isLittleEndian", isLittleEndian());
514  }
515  static get isEvalSupported() {
516    return shadow(this, "isEvalSupported", isEvalSupported());
517  }
518  static get isOffscreenCanvasSupported() {
519    return shadow(this, "isOffscreenCanvasSupported", typeof OffscreenCanvas !== "undefined");
520  }
521  static get isImageDecoderSupported() {
522    return shadow(this, "isImageDecoderSupported", typeof ImageDecoder !== "undefined");
523  }
524  static get isFloat16ArraySupported() {
525    return shadow(this, "isFloat16ArraySupported", typeof Float16Array !== "undefined");
526  }
527  static get isSanitizerSupported() {
528    return shadow(this, "isSanitizerSupported", typeof Sanitizer !== "undefined");
529  }
530  static get platform() {
531    const {
532      platform,
533      userAgent
534    } = navigator;
535    return shadow(this, "platform", {
536      isAndroid: userAgent.includes("Android"),
537      isLinux: platform.includes("Linux"),
538      isMac: platform.includes("Mac"),
539      isWindows: platform.includes("Win"),
540      isFirefox: userAgent.includes("Firefox")
541    });
542  }
543  static get isCSSRoundSupported() {
544    return shadow(this, "isCSSRoundSupported", globalThis.CSS?.supports?.("width: round(1.5px, 1px)"));
545  }
546}
547const hexNumbers = Array.from(Array(256).keys(), n => n.toString(16).padStart(2, "0"));
548class Util {
549  static makeHexColor(r, g, b) {
550    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
551  }
552  static domMatrixToTransform(dm) {
553    return [dm.a, dm.b, dm.c, dm.d, dm.e, dm.f];
554  }
555  static scaleMinMax(transform, minMax) {
556    let temp;
557    if (transform[0]) {
558      if (transform[0] < 0) {
559        temp = minMax[0];
560        minMax[0] = minMax[2];
561        minMax[2] = temp;
562      }
563      minMax[0] *= transform[0];
564      minMax[2] *= transform[0];
565      if (transform[3] < 0) {
566        temp = minMax[1];
567        minMax[1] = minMax[3];
568        minMax[3] = temp;
569      }
570      minMax[1] *= transform[3];
571      minMax[3] *= transform[3];
572    } else {
573      temp = minMax[0];
574      minMax[0] = minMax[1];
575      minMax[1] = temp;
576      temp = minMax[2];
577      minMax[2] = minMax[3];
578      minMax[3] = temp;
579      if (transform[1] < 0) {
580        temp = minMax[1];
581        minMax[1] = minMax[3];
582        minMax[3] = temp;
583      }
584      minMax[1] *= transform[1];
585      minMax[3] *= transform[1];
586      if (transform[2] < 0) {
587        temp = minMax[0];
588        minMax[0] = minMax[2];
589        minMax[2] = temp;
590      }
591      minMax[0] *= transform[2];
592      minMax[2] *= transform[2];
593    }
594    minMax[0] += transform[4];
595    minMax[1] += transform[5];
596    minMax[2] += transform[4];
597    minMax[3] += transform[5];
598  }
599  static transform(m1, m2) {
600    return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
601  }
602  static multiplyByDOMMatrix(m, md) {
603    return [m[0] * md.a + m[2] * md.b, m[1] * md.a + m[3] * md.b, m[0] * md.c + m[2] * md.d, m[1] * md.c + m[3] * md.d, m[0] * md.e + m[2] * md.f + m[4], m[1] * md.e + m[3] * md.f + m[5]];
604  }
605  static applyTransform(p, m, pos = 0) {
606    const p0 = p[pos];
607    const p1 = p[pos + 1];
608    p[pos] = p0 * m[0] + p1 * m[2] + m[4];
609    p[pos + 1] = p0 * m[1] + p1 * m[3] + m[5];
610  }
611  static applyTransformToBezier(p, transform, pos = 0) {
612    const m0 = transform[0];
613    const m1 = transform[1];
614    const m2 = transform[2];
615    const m3 = transform[3];
616    const m4 = transform[4];
617    const m5 = transform[5];
618    for (let i = 0; i < 6; i += 2) {
619      const pI = p[pos + i];
620      const pI1 = p[pos + i + 1];
621      p[pos + i] = pI * m0 + pI1 * m2 + m4;
622      p[pos + i + 1] = pI * m1 + pI1 * m3 + m5;
623    }
624  }
625  static applyInverseTransform(p, m) {
626    const p0 = p[0];
627    const p1 = p[1];
628    const d = m[0] * m[3] - m[1] * m[2];
629    p[0] = (p0 * m[3] - p1 * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
630    p[1] = (-p0 * m[1] + p1 * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
631  }
632  static axialAlignedBoundingBox(rect, transform, output) {
633    const m0 = transform[0];
634    const m1 = transform[1];
635    const m2 = transform[2];
636    const m3 = transform[3];
637    const m4 = transform[4];
638    const m5 = transform[5];
639    const r0 = rect[0];
640    const r1 = rect[1];
641    const r2 = rect[2];
642    const r3 = rect[3];
643    let a0 = m0 * r0 + m4;
644    let a2 = a0;
645    let a1 = m0 * r2 + m4;
646    let a3 = a1;
647    let b0 = m3 * r1 + m5;
648    let b2 = b0;
649    let b1 = m3 * r3 + m5;
650    let b3 = b1;
651    if (m1 !== 0 || m2 !== 0) {
652      const m1r0 = m1 * r0;
653      const m1r2 = m1 * r2;
654      const m2r1 = m2 * r1;
655      const m2r3 = m2 * r3;
656      a0 += m2r1;
657      a3 += m2r1;
658      a1 += m2r3;
659      a2 += m2r3;
660      b0 += m1r0;
661      b3 += m1r0;
662      b1 += m1r2;
663      b2 += m1r2;
664    }
665    output[0] = Math.min(output[0], a0, a1, a2, a3);
666    output[1] = Math.min(output[1], b0, b1, b2, b3);
667    output[2] = Math.max(output[2], a0, a1, a2, a3);
668    output[3] = Math.max(output[3], b0, b1, b2, b3);
669  }
670  static inverseTransform(m) {
671    const d = m[0] * m[3] - m[1] * m[2];
672    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
673  }
674  static singularValueDecompose2dScale(matrix, output) {
675    const m0 = matrix[0];
676    const m1 = matrix[1];
677    const m2 = matrix[2];
678    const m3 = matrix[3];
679    const a = m0 ** 2 + m1 ** 2;
680    const b = m0 * m2 + m1 * m3;
681    const c = m2 ** 2 + m3 ** 2;
682    const first = (a + c) / 2;
683    const second = Math.sqrt(first ** 2 - (a * c - b ** 2));
684    output[0] = Math.sqrt(first + second || 1);
685    output[1] = Math.sqrt(first - second || 1);
686  }
687  static normalizeRect(rect) {
688    const r = rect.slice(0);
689    if (rect[0] > rect[2]) {
690      r[0] = rect[2];
691      r[2] = rect[0];
692    }
693    if (rect[1] > rect[3]) {
694      r[1] = rect[3];
695      r[3] = rect[1];
696    }
697    return r;
698  }
699  static intersect(rect1, rect2) {
700    const xLow = Math.max(Math.min(rect1[0], rect1[2]), Math.min(rect2[0], rect2[2]));
701    const xHigh = Math.min(Math.max(rect1[0], rect1[2]), Math.max(rect2[0], rect2[2]));
702    if (xLow > xHigh) {
703      return null;
704    }
705    const yLow = Math.max(Math.min(rect1[1], rect1[3]), Math.min(rect2[1], rect2[3]));
706    const yHigh = Math.min(Math.max(rect1[1], rect1[3]), Math.max(rect2[1], rect2[3]));
707    if (yLow > yHigh) {
708      return null;
709    }
710    return [xLow, yLow, xHigh, yHigh];
711  }
712  static pointBoundingBox(x, y, minMax) {
713    minMax[0] = Math.min(minMax[0], x);
714    minMax[1] = Math.min(minMax[1], y);
715    minMax[2] = Math.max(minMax[2], x);
716    minMax[3] = Math.max(minMax[3], y);
717  }
718  static rectBoundingBox(x0, y0, x1, y1, minMax) {
719    minMax[0] = Math.min(minMax[0], x0, x1);
720    minMax[1] = Math.min(minMax[1], y0, y1);
721    minMax[2] = Math.max(minMax[2], x0, x1);
722    minMax[3] = Math.max(minMax[3], y0, y1);
723  }
724  static #getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, t, minMax) {
725    if (t <= 0 || t >= 1) {
726      return;
727    }
728    const mt = 1 - t;
729    const tt = t * t;
730    const ttt = tt * t;
731    const x = mt * (mt * (mt * x0 + 3 * t * x1) + 3 * tt * x2) + ttt * x3;
732    const y = mt * (mt * (mt * y0 + 3 * t * y1) + 3 * tt * y2) + ttt * y3;
733    minMax[0] = Math.min(minMax[0], x);
734    minMax[1] = Math.min(minMax[1], y);
735    minMax[2] = Math.max(minMax[2], x);
736    minMax[3] = Math.max(minMax[3], y);
737  }
738  static #getExtremum(x0, x1, x2, x3, y0, y1, y2, y3, a, b, c, minMax) {
739    if (Math.abs(a) < 1e-12) {
740      if (Math.abs(b) >= 1e-12) {
741        this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, -c / b, minMax);
742      }
743      return;
744    }
745    const delta = b ** 2 - 4 * c * a;
746    if (delta < 0) {
747      return;
748    }
749    const sqrtDelta = Math.sqrt(delta);
750    const a2 = 2 * a;
751    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b + sqrtDelta) / a2, minMax);
752    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b - sqrtDelta) / a2, minMax);
753  }
754  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3, minMax) {
755    minMax[0] = Math.min(minMax[0], x0, x3);
756    minMax[1] = Math.min(minMax[1], y0, y3);
757    minMax[2] = Math.max(minMax[2], x0, x3);
758    minMax[3] = Math.max(minMax[3], y0, y3);
759    this.#getExtremum(x0, x1, x2, x3, y0, y1, y2, y3, 3 * (-x0 + 3 * (x1 - x2) + x3), 6 * (x0 - 2 * x1 + x2), 3 * (x1 - x0), minMax);
760    this.#getExtremum(x0, x1, x2, x3, y0, y1, y2, y3, 3 * (-y0 + 3 * (y1 - y2) + y3), 6 * (y0 - 2 * y1 + y2), 3 * (y1 - y0), minMax);
761  }
762}
763const PDFStringTranslateTable = (/* unused pure expression or super */ null && ([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2d8, 0x2c7, 0x2c6, 0x2d9, 0x2dd, 0x2db, 0x2da, 0x2dc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018, 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x141, 0x152, 0x160, 0x178, 0x17d, 0x131, 0x142, 0x153, 0x161, 0x17e, 0, 0x20ac]));
764function stringToPDFString(str, keepEscapeSequence = false) {
765  if (str[0] >= "\xEF") {
766    let encoding;
767    if (str[0] === "\xFE" && str[1] === "\xFF") {
768      encoding = "utf-16be";
769      if (str.length % 2 === 1) {
770        str = str.slice(0, -1);
771      }
772    } else if (str[0] === "\xFF" && str[1] === "\xFE") {
773      encoding = "utf-16le";
774      if (str.length % 2 === 1) {
775        str = str.slice(0, -1);
776      }
777    } else if (str[0] === "\xEF" && str[1] === "\xBB" && str[2] === "\xBF") {
778      encoding = "utf-8";
779    }
780    if (encoding) {

781      try {
782        const decoder = new TextDecoder(encoding, {
783          fatal: true
784        });
785        const buffer = stringToBytes(str);
786        const decoded = decoder.decode(buffer);
787        if (keepEscapeSequence || !decoded.includes("\x1b")) {
788          return decoded;
789        }
790        return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
791      } catch (ex) {
792        warn(`stringToPDFString: "${ex}".`);
793      }
794    }
795  }
796  const strBuf = [];
797  for (let i = 0, ii = str.length; i < ii; i++) {
798    const charCode = str.charCodeAt(i);
799    if (!keepEscapeSequence && charCode === 0x1b) {
800      while (++i < ii && str.charCodeAt(i) !== 0x1b) {}
801      continue;
802    }
803    const code = PDFStringTranslateTable[charCode];
804    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
805  }
806  return strBuf.join("");
807}
808function stringToUTF8String(str) {
809  return decodeURIComponent(escape(str));
810}
811function utf8StringToString(str) {
812  return unescape(encodeURIComponent(str));
813}
814function isArrayEqual(arr1, arr2) {
815  if (arr1.length !== arr2.length) {
816    return false;
817  }
818  for (let i = 0, ii = arr1.length; i < ii; i++) {
819    if (arr1[i] !== arr2[i]) {
820      return false;
821    }
822  }
823  return true;
824}
825function getModificationDate(date = new Date()) {
826  if (!(date instanceof Date)) {
827    date = new Date(date);
828  }
829  const buffer = [date.getUTCFullYear().toString(), (date.getUTCMonth() + 1).toString().padStart(2, "0"), date.getUTCDate().toString().padStart(2, "0"), date.getUTCHours().toString().padStart(2, "0"), date.getUTCMinutes().toString().padStart(2, "0"), date.getUTCSeconds().toString().padStart(2, "0")];
830  return buffer.join("");
831}
832let NormalizeRegex = null;
833let NormalizationMap = null;
834function normalizeUnicode(str) {
835  if (!NormalizeRegex) {
836    NormalizeRegex = /([\u00a0\u00b5\u037e\u0eb3\u2000-\u200a\u202f\u2126\ufb00-\ufb04\ufb06\ufb20-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufba1\ufba4-\ufba9\ufbae-\ufbb1\ufbd3-\ufbdc\ufbde-\ufbe7\ufbea-\ufbf8\ufbfc-\ufbfd\ufc00-\ufc5d\ufc64-\ufcf1\ufcf5-\ufd3d\ufd88\ufdf4\ufdfa-\ufdfb\ufe71\ufe77\ufe79\ufe7b\ufe7d]+)|(\ufb05+)/gu;
837    NormalizationMap = new Map([["ſt", "ſt"]]);
838  }
839  return str.replaceAll(NormalizeRegex, (_, p1, p2) => p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2));
840}
841function getUuid() {
842  if (typeof crypto.randomUUID === "function") {
843    return crypto.randomUUID();
844  }
845  const buf = new Uint8Array(32);
846  crypto.getRandomValues(buf);
847  return bytesToString(buf);
848}
849const AnnotationPrefix = "pdfjs_internal_id_";
850function _isValidExplicitDest(validRef, validName, dest) {
851  if (!Array.isArray(dest) || dest.length < 2) {
852    return false;
853  }
854  const [page, zoom, ...args] = dest;
855  if (!validRef(page) && !Number.isInteger(page)) {
856    return false;
857  }
858  if (!validName(zoom)) {
859    return false;
860  }
861  const argsLen = args.length;
862  let allowNull = true;
863  switch (zoom.name) {
864    case "XYZ":
865      if (argsLen < 2 || argsLen > 3) {
866        return false;
867      }
868      break;
869    case "Fit":
870    case "FitB":
871      return argsLen === 0;
872    case "FitH":
873    case "FitBH":
874    case "FitV":
875    case "FitBV":
876      if (argsLen > 1) {
877        return false;
878      }
879      break;
880    case "FitR":
881      if (argsLen !== 4) {
882        return false;
883      }
884      allowNull = false;
885      break;
886    default:
887      return false;
888  }
889  for (const arg of args) {
890    if (typeof arg === "number" || allowNull && arg === null) {
891      continue;
892    }
893    return false;
894  }
895  return true;
896}
897function MathClamp(v, min, max) {
898  return Math.min(Math.max(v, min), max);
899}
900if (typeof Math.sumPrecise !== "function") {
901  Math.sumPrecise = function (numbers) {
902    return numbers.reduce((a, b) => a + b, 0);
903  };
904}
905
906;// ./src/display/xfa_text.js
907class XfaText {
908  static textContent(xfa) {
909    const items = [];
910    const output = {
911      items,
912      styles: Object.create(null)
913    };
914    function walk(node) {
915      if (!node) {
916        return;
917      }
918      let str = null;
919      const name = node.name;
920      if (name === "#text") {
921        str = node.value;
922      } else if (!XfaText.shouldBuildText(name)) {
923        return;
924      } else if (node?.attributes?.textContent) {
925        str = node.attributes.textContent;
926      } else if (node.value) {
927        str = node.value;
928      }
929      if (str !== null) {
930        items.push({
931          str
932        });
933      }
934      if (!node.children) {
935        return;
936      }
937      for (const child of node.children) {
938        walk(child);
939      }
940    }
941    walk(xfa);
942    return output;
943  }
944  static shouldBuildText(name) {
945    return !(name === "textarea" || name === "input" || name === "option" || name === "select");
946  }
947}
948
949;// ./src/display/xfa_layer.js
950
951class XfaLayer {
952  static setupStorage(html, id, element, storage, intent) {
953    const storedData = storage.getValue(id, {
954      value: null
955    });
956    switch (element.name) {
957      case "textarea":
958        if (storedData.value !== null) {
959          html.textContent = storedData.value;
960        }
961        if (intent === "print") {
962          break;
963        }
964        html.addEventListener("input", event => {
965          storage.setValue(id, {
966            value: event.target.value
967          });
968        });
969        break;
970      case "input":
971        if (element.attributes.type === "radio" || element.attributes.type === "checkbox") {
972          if (storedData.value === element.attributes.xfaOn) {
973            html.setAttribute("checked", true);
974          } else if (storedData.value === element.attributes.xfaOff) {
975            html.removeAttribute("checked");
976          }
977          if (intent === "print") {
978            break;
979          }
980          html.addEventListener("change", event => {
981            storage.setValue(id, {
982              value: event.target.checked ? event.target.getAttribute("xfaOn") : event.target.getAttribute("xfaOff")
983            });
984          });
985        } else {
986          if (storedData.value !== null) {
987            html.setAttribute("value", storedData.value);
988          }
989          if (intent === "print") {
990            break;
991          }
992          html.addEventListener("input", event => {
993            storage.setValue(id, {
994              value: event.target.value
995            });
996          });
997        }
998        break;
999      case "select":
1000        if (storedData.value !== null) {
1001          html.setAttribute("value", storedData.value);
1002          for (const option of element.children) {
1003            if (option.attributes.value === storedData.value) {
1004              option.attributes.selected = true;
1005            } else if (option.attributes.hasOwnProperty("selected")) {
1006              delete option.attributes.selected;
1007            }
1008          }
1009        }
1010        html.addEventListener("input", event => {
1011          const options = event.target.options;
1012          const value = options.selectedIndex === -1 ? "" : options[options.selectedIndex].value;
1013          storage.setValue(id, {
1014            value
1015          });
1016        });
1017        break;
1018    }
1019  }
1020  static setAttributes({
1021    html,
1022    element,
1023    storage = null,
1024    intent,
1025    linkService
1026  }) {
1027    const {
1028      attributes
1029    } = element;
1030    const isHTMLAnchorElement = html instanceof HTMLAnchorElement;
1031    if (attributes.type === "radio") {
1032      attributes.name = `${attributes.name}-${intent}`;
1033    }
1034    for (const [key, value] of Object.entries(attributes)) {
1035      if (value === null || value === undefined) {
1036        continue;
1037      }
1038      switch (key) {
1039        case "class":
1040          if (value.length) {
1041            html.setAttribute(key, value.join(" "));
1042          }
1043          break;
1044        case "dataId":
1045          break;
1046        case "id":
1047          html.setAttribute("data-element-id", value);
1048          break;
1049        case "style":
1050          Object.assign(html.style, value);
1051          break;
1052        case "textContent":
1053          html.textContent = value;
1054          break;
1055        default:
1056          if (!isHTMLAnchorElement || key !== "href" && key !== "newWindow") {
1057            html.setAttribute(key, value);
1058          }
1059      }
1060    }
1061    if (isHTMLAnchorElement) {
1062      linkService.addLinkAttributes(html, attributes.href, attributes.newWindow);
1063    }
1064    if (storage && attributes.dataId) {
1065      this.setupStorage(html, attributes.dataId, element, storage);
1066    }
1067  }
1068  static render(parameters) {
1069    const storage = parameters.annotationStorage;
1070    const linkService = parameters.linkService;
1071    const root = parameters.xfaHtml;
1072    const intent = parameters.intent || "display";
1073    const rootHtml = document.createElement(root.name);
1074    if (root.attributes) {
1075      this.setAttributes({
1076        html: rootHtml,
1077        element: root,
1078        intent,
1079        linkService
1080      });
1081    }
1082    const isNotForRichText = intent !== "richText";
1083    const rootDiv = parameters.div;
1084    rootDiv.append(rootHtml);
1085    if (parameters.viewport) {
1086      const transform = `matrix(${parameters.viewport.transform.join(",")})`;
1087      rootDiv.style.transform = transform;
1088    }
1089    if (isNotForRichText) {
1090      rootDiv.setAttribute("class", "xfaLayer xfaFont");
1091    }
1092    const textDivs = [];
1093    if (root.children.length === 0) {
1094      if (root.value) {
1095        const node = document.createTextNode(root.value);
1096        rootHtml.append(node);
1097        if (isNotForRichText && XfaText.shouldBuildText(root.name)) {
1098          textDivs.push(node);
1099        }
1100      }
1101      return {
1102        textDivs
1103      };
1104    }
1105    const stack = [[root, -1, rootHtml]];
1106    while (stack.length > 0) {
1107      const [parent, i, html] = stack.at(-1);
1108      if (i + 1 === parent.children.length) {
1109        stack.pop();
1110        continue;
1111      }
1112      const child = parent.children[++stack.at(-1)[1]];
1113      if (child === null) {
1114        continue;
1115      }
1116      const {
1117        name
1118      } = child;
1119      if (name === "#text") {
1120        const node = document.createTextNode(child.value);
1121        textDivs.push(node);
1122        html.append(node);
1123        continue;
1124      }
1125      const childHtml = child?.attributes?.xmlns ? document.createElementNS(child.attributes.xmlns, name) : document.createElement(name);
1126      html.append(childHtml);
1127      if (child.attributes) {
1128        this.setAttributes({
1129          html: childHtml,
1130          element: child,
1131          storage,
1132          intent,
1133          linkService
1134        });
1135      }
1136      if (child.children?.length > 0) {
1137        stack.push([child, -1, childHtml]);
1138      } else if (child.value) {
1139        const node = document.createTextNode(child.value);
1140        if (isNotForRichText && XfaText.shouldBuildText(name)) {
1141          textDivs.push(node);
1142        }
1143        childHtml.append(node);
1144      }
1145    }
1146    for (const el of rootDiv.querySelectorAll(".xfaNonInteractive input, .xfaNonInteractive textarea")) {
1147      el.setAttribute("readOnly", true);
1148    }
1149    return {
1150      textDivs
1151    };
1152  }
1153  static update(parameters) {
1154    const transform = `matrix(${parameters.viewport.transform.join(",")})`;
1155    parameters.div.style.transform = transform;
1156    parameters.div.hidden = false;
1157  }
1158}
1159
1160;// ./src/display/display_utils.js
1161
1162
1163const SVG_NS = "http://www.w3.org/2000/svg";
1164class PixelsPerInch {
1165  static CSS = 96.0;
1166  static PDF = 72.0;
1167  static PDF_TO_CSS_UNITS = this.CSS / this.PDF;
1168}
1169async function fetchData(url, type = "text") {
1170  if (isValidFetchUrl(url, document.baseURI)) {
1171    const response = await fetch(url);
1172    if (!response.ok) {
1173      throw new Error(response.statusText);
1174    }
1175    switch (type) {
1176      case "arraybuffer":
1177        return response.arrayBuffer();
1178      case "blob":
1179        return response.blob();
1180      case "json":
1181        return response.json();
1182    }
1183    return response.text();
1184  }
1185  return new Promise((resolve, reject) => {
1186    const request = new XMLHttpRequest();
1187    request.open("GET", url, true);
1188    request.responseType = type;
1189    request.onreadystatechange = () => {
1190      if (request.readyState !== XMLHttpRequest.DONE) {
1191        return;
1192      }
1193      if (request.status === 200 || request.status === 0) {
1194        switch (type) {
1195          case "arraybuffer":
1196          case "blob":
1197          case "json":
1198            resolve(request.response);
1199            return;
1200        }
1201        resolve(request.responseText);
1202        return;
1203      }
1204      reject(new Error(request.statusText));
1205    };
1206    request.send(null);
1207  });
1208}
1209class PageViewport {
1210  constructor({
1211    viewBox,
1212    userUnit,
1213    scale,
1214    rotation,
1215    offsetX = 0,
1216    offsetY = 0,
1217    dontFlip = false
1218  }) {
1219    this.viewBox = viewBox;
1220    this.userUnit = userUnit;
1221    this.scale = scale;
1222    this.rotation = rotation;
1223    this.offsetX = offsetX;
1224    this.offsetY = offsetY;
1225    scale *= userUnit;
1226    const centerX = (viewBox[2] + viewBox[0]) / 2;
1227    const centerY = (viewBox[3] + viewBox[1]) / 2;
1228    let rotateA, rotateB, rotateC, rotateD;
1229    rotation %= 360;
1230    if (rotation < 0) {
1231      rotation += 360;
1232    }
1233    switch (rotation) {
1234      case 180:
1235        rotateA = -1;
1236        rotateB = 0;
1237        rotateC = 0;
1238        rotateD = 1;
1239        break;
1240      case 90:
1241        rotateA = 0;
1242        rotateB = 1;
1243        rotateC = 1;
1244        rotateD = 0;
1245        break;
1246      case 270:
1247        rotateA = 0;
1248        rotateB = -1;
1249        rotateC = -1;
1250        rotateD = 0;
1251        break;
1252      case 0:
1253        rotateA = 1;
1254        rotateB = 0;
1255        rotateC = 0;
1256        rotateD = -1;
1257        break;
1258      default:
1259        throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.");
1260    }
1261    if (dontFlip) {
1262      rotateC = -rotateC;
1263      rotateD = -rotateD;
1264    }
1265    let offsetCanvasX, offsetCanvasY;
1266    let width, height;
1267    if (rotateA === 0) {
1268      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
1269      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
1270      width = (viewBox[3] - viewBox[1]) * scale;
1271      height = (viewBox[2] - viewBox[0]) * scale;
1272    } else {
1273      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
1274      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
1275      width = (viewBox[2] - viewBox[0]) * scale;
1276      height = (viewBox[3] - viewBox[1]) * scale;
1277    }
1278    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
1279    this.width = width;
1280    this.height = height;
1281  }
1282  get rawDims() {
1283    const dims = this.viewBox;
1284    return shadow(this, "rawDims", {
1285      pageWidth: dims[2] - dims[0],
1286      pageHeight: dims[3] - dims[1],
1287      pageX: dims[0],
1288      pageY: dims[1]
1289    });
1290  }
1291  clone({
1292    scale = this.scale,
1293    rotation = this.rotation,
1294    offsetX = this.offsetX,
1295    offsetY = this.offsetY,
1296    dontFlip = false
1297  } = {}) {
1298    return new PageViewport({
1299      viewBox: this.viewBox.slice(),
1300      userUnit: this.userUnit,
1301      scale,
1302      rotation,
1303      offsetX,
1304      offsetY,
1305      dontFlip
1306    });
1307  }
1308  convertToViewportPoint(x, y) {
1309    const p = [x, y];
1310    Util.applyTransform(p, this.transform);
1311    return p;
1312  }
1313  convertToViewportRectangle(rect) {
1314    const topLeft = [rect[0], rect[1]];
1315    Util.applyTransform(topLeft, this.transform);
1316    const bottomRight = [rect[2], rect[3]];
1317    Util.applyTransform(bottomRight, this.transform);
1318    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
1319  }
1320  convertToPdfPoint(x, y) {
1321    const p = [x, y];
1322    Util.applyInverseTransform(p, this.transform);
1323    return p;
1324  }
1325}
1326class RenderingCancelledException extends BaseException {
1327  constructor(msg, extraDelay = 0) {
1328    super(msg, "RenderingCancelledException");
1329    this.extraDelay = extraDelay;
1330  }
1331}
1332function isDataScheme(url) {
1333  const ii = url.length;
1334  let i = 0;
1335  while (i < ii && url[i].trim() === "") {
1336    i++;
1337  }
1338  return url.substring(i, i + 5).toLowerCase() === "data:";
1339}
1340function isPdfFile(filename) {
1341  return typeof filename === "string" && /\.pdf$/i.test(filename);
1342}
1343function getFilenameFromUrl(url) {
1344  [url] = url.split(/[#?]/, 1);
1345  return url.substring(url.lastIndexOf("/") + 1);
1346}
1347function getPdfFilenameFromUrl(url, defaultFilename = "document.pdf") {
1348  if (typeof url !== "string") {
1349    return defaultFilename;
1350  }
1351  if (isDataScheme(url)) {
1352    warn('getPdfFilenameFromUrl: ignore "data:"-URL for performance reasons.');
1353    return defaultFilename;
1354  }
1355  const getURL = urlString => {
1356    try {
1357      return new URL(urlString);
1358    } catch {
1359      try {
1360        return new URL(decodeURIComponent(urlString));
1361      } catch {
1362        try {
1363          return new URL(urlString, "https://foo.bar");
1364        } catch {
1365          try {
1366            return new URL(decodeURIComponent(urlString), "https://foo.bar");
1367          } catch {
1368            return null;
1369          }
1370        }
1371      }
1372    }
1373  };
1374  const newURL = getURL(url);
1375  if (!newURL) {
1376    return defaultFilename;
1377  }
1378  const decode = name => {
1379    try {
1380      let decoded = decodeURIComponent(name);
1381      if (decoded.includes("/")) {
1382        decoded = decoded.split("/").at(-1);
1383        if (decoded.test(/^\.pdf$/i)) {
1384          return decoded;
1385        }
1386        return name;
1387      }
1388      return decoded;
1389    } catch {
1390      return name;
1391    }
1392  };
1393  const pdfRegex = /\.pdf$/i;
1394  const filename = newURL.pathname.split("/").at(-1);
1395  if (pdfRegex.test(filename)) {
1396    return decode(filename);
1397  }
1398  if (newURL.searchParams.size > 0) {
1399    const values = Array.from(newURL.searchParams.values()).reverse();
1400    for (const value of values) {
1401      if (pdfRegex.test(value)) {
1402        return decode(value);
1403      }
1404    }
1405    const keys = Array.from(newURL.searchParams.keys()).reverse();
1406    for (const key of keys) {
1407      if (pdfRegex.test(key)) {
1408        return decode(key);
1409      }
1410    }
1411  }
1412  if (newURL.hash) {
1413    const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
1414    const hashFilename = reFilename.exec(newURL.hash);
1415    if (hashFilename) {
1416      return decode(hashFilename[0]);
1417    }
1418  }
1419  return defaultFilename;
1420}
1421class StatTimer {
1422  started = Object.create(null);
1423  times = [];
1424  time(name) {
1425    if (name in this.started) {
1426      warn(`Timer is already running for ${name}`);
1427    }
1428    this.started[name] = Date.now();
1429  }
1430  timeEnd(name) {
1431    if (!(name in this.started)) {
1432      warn(`Timer has not been started for ${name}`);
1433    }
1434    this.times.push({
1435      name,
1436      start: this.started[name],
1437      end: Date.now()
1438    });
1439    delete this.started[name];
1440  }
1441  toString() {
1442    const outBuf = [];
1443    let longest = 0;
1444    for (const {
1445      name
1446    } of this.times) {
1447      longest = Math.max(name.length, longest);
1448    }
1449    for (const {
1450      name,
1451      start,
1452      end
1453    } of this.times) {
1454      outBuf.push(`${name.padEnd(longest)} ${end - start}

1636  }
1637  static get pixelRatio() {
1638    return globalThis.devicePixelRatio || 1;
1639  }
1640  static capPixels(maxPixels, capAreaFactor) {
1641    if (capAreaFactor >= 0) {
1642      const winPixels = Math.ceil(window.screen.availWidth * window.screen.availHeight * this.pixelRatio ** 2 * (1 + capAreaFactor / 100));
1643      return maxPixels > 0 ? Math.min(maxPixels, winPixels) : winPixels;
1644    }
1645    return maxPixels;
1646  }
1647}
1648const SupportedImageMimeTypes = ["image/apng", "image/avif", "image/bmp", "image/gif", "image/jpeg", "image/png", "image/svg+xml", "image/webp", "image/x-icon"];
1649class ColorScheme {
1650  static get isDarkMode() {
1651    return shadow(this, "isDarkMode", !!window?.matchMedia?.("(prefers-color-scheme: dark)").matches);
1652  }
1653}
1654class CSSConstants {
1655  static get commentForegroundColor() {
1656    const element = document.createElement("span");
1657    element.classList.add("comment", "sidebar");
1658    const {
1659      style
1660    } = element;
1661    style.width = style.height = "0";
1662    style.display = "none";
1663    style.color = "var(--comment-fg-color)";
1664    document.body.append(element);
1665    const {
1666      color
1667    } = window.getComputedStyle(element);
1668    element.remove();
1669    return shadow(this, "commentForegroundColor", getRGB(color));
1670  }
1671}
1672function applyOpacity(r, g, b, opacity) {
1673  opacity = Math.min(Math.max(opacity ?? 1, 0), 1);
1674  const white = 255 * (1 - opacity);
1675  r = Math.round(r * opacity + white);
1676  g = Math.round(g * opacity + white);
1677  b = Math.round(b * opacity + white);
1678  return [r, g, b];
1679}
1680function RGBToHSL(rgb, output) {
1681  const r = rgb[0] / 255;
1682  const g = rgb[1] / 255;
1683  const b = rgb[2] / 255;
1684  const max = Math.max(r, g, b);
1685  const min = Math.min(r, g, b);
1686  const l = (max + min) / 2;
1687  if (max === min) {
1688    output[0] = output[1] = 0;
1689  } else {
1690    const d = max - min;
1691    output[1] = l < 0.5 ? d / (max + min) : d / (2 - max - min);
1692    switch (max) {
1693      case r:
1694        output[0] = ((g - b) / d + (g < b ? 6 : 0)) * 60;
1695        break;
1696      case g:
1697        output[0] = ((b - r) / d + 2) * 60;
1698        break;
1699      case b:
1700        output[0] = ((r - g) / d + 4) * 60;
1701        break;
1702    }
1703  }
1704  output[2] = l;
1705}
1706function HSLToRGB(hsl, output) {
1707  const h = hsl[0];
1708  const s = hsl[1];
1709  const l = hsl[2];
1710  const c = (1 - Math.abs(2 * l - 1)) * s;
1711  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
1712  const m = l - c / 2;
1713  switch (Math.floor(h / 60)) {
1714    case 0:
1715      output[0] = c + m;
1716      output[1] = x + m;
1717      output[2] = m;
1718      break;
1719    case 1:
1720      output[0] = x + m;
1721      output[1] = c + m;
1722      output[2] = m;
1723      break;
1724    case 2:
1725      output[0] = m;
1726      output[1] = c + m;
1727      output[2] = x + m;
1728      break;
1729    case 3:
1730      output[0] = m;
1731      output[1] = x + m;
1732      output[2] = c + m;
1733      break;
1734    case 4:
1735      output[0] = x + m;
1736      output[1] = m;
1737      output[2] = c + m;
1738      break;
1739    case 5:
1740    case 6:
1741      output[0] = c + m;
1742      output[1] = m;
1743      output[2] = x + m;
1744      break;
1745  }
1746}
1747function computeLuminance(x) {
1748  return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
1749}
1750function contrastRatio(hsl1, hsl2, output) {
1751  HSLToRGB(hsl1, output);
1752  output.map(computeLuminance);
1753  const lum1 = 0.2126 * output[0] + 0.7152 * output[1] + 0.0722 * output[2];
1754  HSLToRGB(hsl2, output);
1755  output.map(computeLuminance);
1756  const lum2 = 0.2126 * output[0] + 0.7152 * output[1] + 0.0722 * output[2];
1757  return lum1 > lum2 ? (lum1 + 0.05) / (lum2 + 0.05) : (lum2 + 0.05) / (lum1 + 0.05);
1758}
1759const contrastCache = new Map();
1760function findContrastColor(baseColor, fixedColor) {
1761  const key = baseColor[0] + baseColor[1] * 0x100 + baseColor[2] * 0x10000 + fixedColor[0] * 0x1000000 + fixedColor[1] * 0x100000000 + fixedColor[2] * 0x10000000000;
1762  let cachedValue = contrastCache.get(key);
1763  if (cachedValue) {
1764    return cachedValue;
1765  }
1766  const array = new Float32Array(9);
1767  const output = array.subarray(0, 3);
1768  const baseHSL = array.subarray(3, 6);
1769  RGBToHSL(baseColor, baseHSL);
1770  const fixedHSL = array.subarray(6, 9);
1771  RGBToHSL(fixedColor, fixedHSL);
1772  const isFixedColorDark = fixedHSL[2] < 0.5;
1773  const minContrast = isFixedColorDark ? 12 : 4.5;
1774  baseHSL[2] = isFixedColorDark ? Math.sqrt(baseHSL[2]) : 1 - Math.sqrt(1 - baseHSL[2]);
1775  if (contrastRatio(baseHSL, fixedHSL, output) < minContrast) {
1776    let start, end;
1777    if (isFixedColorDark) {
1778      start = baseHSL[2];
1779      end = 1;
1780    } else {
1781      start = 0;
1782      end = baseHSL[2];
1783    }
1784    const PRECISION = 0.005;
1785    while (end - start > PRECISION) {
1786      const mid = baseHSL[2] = (start + end) / 2;
1787      if (isFixedColorDark === contrastRatio(baseHSL, fixedHSL, output) < minContrast) {
1788        start = mid;
1789      } else {
1790        end = mid;
1791      }
1792    }
1793    baseHSL[2] = isFixedColorDark ? end : start;
1794  }
1795  HSLToRGB(baseHSL, output);
1796  cachedValue = Util.makeHexColor(Math.round(output[0] * 255), Math.round(output[1] * 255), Math.round(output[2] * 255));
1797  contrastCache.set(key, cachedValue);
1798  return cachedValue;
1799}
1800function renderRichText({
1801  html,
1802  dir,
1803  className
1804}, container) {
1805  const fragment = document.createDocumentFragment();
1806  if (typeof html === "string") {
1807    const p = document.createElement("p");
1808    p.dir = dir || "auto";
1809    const lines = html.split(/(?:\r\n?|\n)/);
1810    for (let i = 0, ii = lines.length; i < ii; ++i) {
1811      const line = lines[i];
1812      p.append(document.createTextNode(line));
1813      if (i < ii - 1) {
1814        p.append(document.createElement("br"));
1815      }
1816    }
1817    fragment.append(p);
1818  } else {
1819    XfaLayer.render({
1820      xfaHtml: html,
1821      div: fragment,
1822      intent: "richText"
1823    });
1824  }
1825  fragment.firstElementChild.classList.add("richText", className);
1826  container.append(fragment);
1827}
1828function makePathFromDrawOPS(data) {
1829  const path = new Path2D();
1830  if (!data) {
1831    return path;
1832  }
1833  for (let i = 0, ii = data.length; i < ii;) {
1834    switch (data[i++]) {
1835      case DrawOPS.moveTo:
1836        path.moveTo(data[i++], data[i++]);
1837        break;
1838      case DrawOPS.lineTo:
1839        path.lineTo(data[i++], data[i++]);
1840        break;
1841      case DrawOPS.curveTo:
1842        path.bezierCurveTo(data[i++], data[i++], data[i++], data[i++], data[i++], data[i++]);
1843        break;
1844      case DrawOPS.quadraticCurveTo:
1845        path.quadraticCurveTo(data[i++], data[i++], data[i++], data[i++]);
1846        break;
1847      case DrawOPS.closePath:

1999        signal
2000      });
2001    }
2002    const buttons = this.#buttons = document.createElement("div");
2003    buttons.className = "buttons";
2004    editToolbar.append(buttons);
2005    const position = this.#editor.toolbarPosition;
2006    if (position) {
2007      const {
2008        style
2009      } = editToolbar;
2010      const x = this.#editor._uiManager.direction === "ltr" ? 1 - position[0] : position[0];
2011      style.insetInlineEnd = `${100 * x}%`;
2012      style.top = `calc(${100 * position[1]}% + var(--editor-toolbar-vert-offset))`;
2013    }
2014    return editToolbar;
2015  }
2016  get div() {
2017    return this.#toolbar;
2018  }
2019  static #pointerDown(e) {
2020    e.stopPropagation();
2021  }
2022  #focusIn(e) {
2023    this.#editor._focusEventsAllowed = false;
2024    stopEvent(e);
2025  }
2026  #focusOut(e) {
2027    this.#editor._focusEventsAllowed = true;
2028    stopEvent(e);
2029  }
2030  #addListenersToElement(element) {
2031    const signal = this.#editor._uiManager._signal;
2032    if (!(signal instanceof AbortSignal) || signal.aborted) {
2033      return false;
2034    }
2035    element.addEventListener("focusin", this.#focusIn.bind(this), {
2036      capture: true,
2037      signal
2038    });
2039    element.addEventListener("focusout", this.#focusOut.bind(this), {
2040      capture: true,
2041      signal
2042    });
2043    element.addEventListener("contextmenu", noContextMenu, {
2044      signal
2045    });
2046    return true;
2047  }
2048  hide() {
2049    this.#toolbar.classList.add("hidden");
2050    this.#colorPicker?.hideDropdown();
2051  }
2052  show() {
2053    this.#toolbar.classList.remove("hidden");
2054    this.#altText?.shown();
2055    this.#comment?.shown();
2056  }
2057  addDeleteButton() {
2058    const {
2059      editorType,
2060      _uiManager
2061    } = this.#editor;
2062    const button = document.createElement("button");
2063    button.classList.add("basic", "deleteButton");
2064    button.tabIndex = 0;
2065    button.setAttribute("data-l10n-id", EditorToolbar.#l10nRemove[editorType]);
2066    if (this.#addListenersToElement(button)) {
2067      button.addEventListener("click", e => {
2068        _uiManager.delete();
2069      }, {
2070        signal: _uiManager._signal
2071      });
2072    }
2073    this.#buttons.append(button);
2074  }
2075  get #divider() {
2076    const divider = document.createElement("div");
2077    divider.className = "divider";
2078    return divider;
2079  }
2080  async addAltText(altText) {
2081    const button = await altText.render();
2082    this.#addListenersToElement(button);
2083    this.#buttons.append(button, this.#divider);
2084    this.#altText = altText;
2085  }
2086  addComment(comment, beforeElement = null) {
2087    if (this.#comment) {
2088      return;
2089    }
2090    const button = comment.renderForToolbar();
2091    if (!button) {
2092      return;
2093    }
2094    this.#addListenersToElement(button);
2095    const divider = this.#commentButtonDivider = this.#divider;
2096    if (!beforeElement) {
2097      this.#buttons.append(button, divider);
2098    } else {
2099      this.#buttons.insertBefore(button, beforeElement);
2100      this.#buttons.insertBefore(divider, beforeElement);
2101    }
2102    this.#comment = comment;
2103    comment.toolbar = this;
2104  }
2105  addColorPicker(colorPicker) {
2106    if (this.#colorPicker) {
2107      return;
2108    }
2109    this.#colorPicker = colorPicker;
2110    const button = colorPicker.renderButton();
2111    this.#addListenersToElement(button);
2112    this.#buttons.append(button, this.#divider);
2113  }
2114  async addEditSignatureButton(signatureManager) {
2115    const button = this.#signatureDescriptionButton = await signatureManager.renderEditButton(this.#editor);
2116    this.#addListenersToElement(button);
2117    this.#buttons.append(button, this.#divider);
2118  }
2119  removeButton(name) {
2120    switch (name) {
2121      case "comment":
2122        this.#comment?.removeToolbarCommentButton();
2123        this.#comment = null;
2124        this.#commentButtonDivider?.remove();
2125        this.#commentButtonDivider = null;
2126        break;
2127    }
2128  }
2129  async addButton(name, tool) {
2130    switch (name) {
2131      case "colorPicker":
2132        if (tool) {
2133          this.addColorPicker(tool);
2134        }
2135        break;
2136      case "altText":
2137        if (tool) {
2138          await this.addAltText(tool);
2139        }
2140        break;
2141      case "editSignature":
2142        if (tool) {
2143          await this.addEditSignatureButton(tool);
2144        }
2145        break;
2146      case "delete":
2147        this.addDeleteButton();
2148        break;
2149      case "comment":
2150        if (tool) {
2151          this.addComment(tool);
2152        }
2153        break;
2154    }
2155  }
2156  async addButtonBefore(name, tool, beforeSelector) {
2157    if (!tool && name === "comment") {
2158      return;
2159    }
2160    const beforeElement = this.#buttons.querySelector(beforeSelector);
2161    if (!beforeElement) {
2162      return;
2163    }
2164    if (name === "comment") {
2165      this.addComment(tool, beforeElement);
2166    }
2167  }
2168  updateEditSignatureButton(description) {
2169    if (this.#signatureDescriptionButton) {
2170      this.#signatureDescriptionButton.title = description;
2171    }
2172  }
2173  remove() {
2174    this.#toolbar.remove();
2175    this.#colorPicker?.destroy();
2176    this.#colorPicker = null;
2177  }
2178}
2179class FloatingToolbar {
2180  #buttons = null;
2181  #toolbar = null;
2182  #uiManager;
2183  constructor(uiManager) {
2184    this.#uiManager = uiManager;
2185  }
2186  #render() {
2187    const editToolbar = this.#toolbar = document.createElement("div");
2188    editToolbar.className = "editToolbar";
2189    editToolbar.setAttribute("role", "toolbar");
2190    const signal = this.#uiManager._signal;
2191    if (signal instanceof AbortSignal && !signal.aborted) {
2192      editToolbar.addEventListener("contextmenu", noContextMenu, {
2193        signal
2194      });
2195    }
2196    const buttons = this.#buttons = document.createElement("div");
2197    buttons.className = "buttons";
2198    editToolbar.append(buttons);
2199    if (this.#uiManager.hasCommentManager()) {
2200      this.#makeButton("commentButton", `pdfjs-comment-floating-button`, "pdfjs-comment-floating-button-label", () => {
2201        this.#uiManager.commentSelection("floating_button");
2202      });
2203    }
2204    this.#makeButton("highlightButton", `pdfjs-highlight-floating-button1`, "pdfjs-highlight-floating-button-label", () => {
2205      this.#uiManager.highlightSelection("floating_button");
2206    });
2207    return editToolbar;
2208  }
2209  #getLastPoint(boxes, isLTR) {
2210    let lastY = 0;
2211    let lastX = 0;
2212    for (const box of boxes) {
2213      const y = box.y + box.height;
2214      if (y < lastY) {
2215        continue;
2216      }
2217      const x = box.x + (isLTR ? box.width : 0);
2218      if (y > lastY) {
2219        lastX = x;
2220        lastY = y;
2221        continue;
2222      }
2223      if (isLTR) {
2224        if (x > lastX) {
2225          lastX = x;
2226        }
2227      } else if (x < lastX) {
2228        lastX = x;
2229      }
2230    }
2231    return [isLTR ? 1 - lastX : lastX, lastY];
2232  }
2233  show(parent, boxes, isLTR) {
2234    const [x, y] = this.#getLastPoint(boxes, isLTR);
2235    const {
2236      style
2237    } = this.#toolbar ||= this.#render();
2238    parent.append(this.#toolbar);
2239    style.insetInlineEnd = `${100 * x}%`;
2240    style.top = `calc(${100 * y}% + var(--editor-toolbar-vert-offset))`;
2241  }
2242  hide() {
2243    this.#toolbar.remove();
2244  }
2245  #makeButton(buttonClass, l10nId, labelL10nId, clickHandler) {
2246    const button = document.createElement("button");
2247    button.classList.add("basic", buttonClass);
2248    button.tabIndex = 0;
2249    button.setAttribute("data-l10n-id", l10nId);
2250    const span = document.createElement("span");
2251    button.append(span);
2252    span.className = "visuallyHidden";
2253    span.setAttribute("data-l10n-id", labelL10nId);
2254    const signal = this.#uiManager._signal;
2255    if (signal instanceof AbortSignal && !signal.aborted) {
2256      button.addEventListener("contextmenu", noContextMenu, {
2257        signal
2258      });
2259      button.addEventListener("click", clickHandler, {
2260        signal
2261      });
2262    }
2263    this.#buttons.append(button);
2264  }
2265}
2266
2267;// ./src/display/editor/tools.js
2268
2269
2270
2271function bindEvents(obj, element, names) {
2272  for (const name of names) {
2273    element.addEventListener(name, obj[name].bind(obj));
2274  }
2275}
2276class CurrentPointers {
2277  static #pointerId = NaN;
2278  static #pointerIds = null;
2279  static #moveTimestamp = NaN;
2280  static #pointerType = null;
2281  static initializeAndAddPointerId(pointerId) {
2282    (CurrentPointers.#pointerIds ||= new Set()).add(pointerId);
2283  }
2284  static setPointer(pointerType, pointerId) {
2285    CurrentPointers.#pointerId ||= pointerId;
2286    CurrentPointers.#pointerType ??= pointerType;
2287  }
2288  static setTimeStamp(timeStamp) {
2289    CurrentPointers.#moveTimestamp = timeStamp;
2290  }
2291  static isSamePointerId(pointerId) {
2292    return CurrentPointers.#pointerId === pointerId;
2293  }
2294  static isSamePointerIdOrRemove(pointerId) {
2295    if (CurrentPointers.#pointerId === pointerId) {
2296      return true;
2297    }
2298    CurrentPointers.#pointerIds?.delete(pointerId);
2299    return false;
2300  }
2301  static isSamePointerType(pointerType) {
2302    return CurrentPointers.#pointerType === pointerType;
2303  }
2304  static isInitializedAndDifferentPointerType(pointerType) {
2305    return CurrentPointers.#pointerType !== null && !CurrentPointers.isSamePointerType(pointerType);
2306  }
2307  static isSameTimeStamp(timeStamp) {
2308    return CurrentPointers.#moveTimestamp === timeStamp;
2309  }
2310  static isUsingMultiplePointers() {
2311    return CurrentPointers.#pointerIds?.size >= 1;
2312  }
2313  static clearPointerType() {
2314    CurrentPointers.#pointerType = null;
2315  }
2316  static clearPointerIds() {
2317    CurrentPointers.#pointerId = NaN;
2318    CurrentPointers.#pointerIds = null;
2319  }
2320  static clearTimeStamp() {
2321    CurrentPointers.#moveTimestamp = NaN;
2322  }
2323}
2324class IdManager {
2325  #id = 0;
2326  get id() {
2327    return `${AnnotationEditorPrefix}${this.#id++}`;
2328  }
2329}
2330class ImageManager {
2331  #baseId = getUuid();
2332  #id = 0;
2333  #cache = null;
2334  static get _isSVGFittingCanvas() {
2335    const svg = `data:image/svg+xml;charset=UTF-8,<svg viewBox="0 0 1 1" width="1" height="1" xmlns="http://www.w3.org/2000/svg"><rect width="1" height="1" style="fill:red;"/></svg>`;
2336    const canvas = new OffscreenCanvas(1, 3);
2337    const ctx = canvas.getContext("2d", {
2338      willReadFrequently: true
2339    });
2340    const image = new Image();
2341    image.src = svg;
2342    const promise = image.decode().then(() => {
2343      ctx.drawImage(image, 0, 0, 1, 1, 0, 0, 1, 3);
2344      return new Uint32Array(ctx.getImageData(0, 0, 1, 1).data.buffer)[0] === 0;
2345    });
2346    return shadow(this, "_isSVGFittingCanvas", promise);
2347  }
2348  async #get(key, rawData) {
2349    this.#cache ||= new Map();
2350    let data = this.#cache.get(key);
2351    if (data === null) {
2352      return null;
2353    }
2354    if (data?.bitmap) {
2355      data.refCounter += 1;
2356      return data;
2357    }
2358    try {
2359      data ||= {
2360        bitmap: null,
2361        id: `image_${this.#baseId}_${this.#id++}`,
2362        refCounter: 0,
2363        isSvg: false
2364      };
2365      let image;
2366      if (typeof rawData === "string") {
2367        data.url = rawData;
2368        image = await fetchData(rawData, "blob");
2369      } else if (rawData instanceof File) {
2370        image = data.file = rawData;
2371      } else if (rawData instanceof Blob) {
2372        image = rawData;
2373      }
2374      if (image.type === "image/svg+xml") {
2375        const mustRemoveAspectRatioPromise = ImageManager._isSVGFittingCanvas;
2376        const fileReader = new FileReader();
2377        const imageElement = new Image();
2378        const imagePromise = new Promise((resolve, reject) => {
2379          imageElement.onload = () => {
2380            data.bitmap = imageElement;
2381            data.isSvg = true;
2382            resolve();
2383          };
2384          fileReader.onload = async () => {
2385            const url = data.svgUrl = fileReader.result;
2386            imageElement.src = (await mustRemoveAspectRatioPromise) ? `${url}#svgView(preserveAspectRatio(none))` : url;
2387          };
2388          imageElement.onerror = fileReader.onerror = reject;
2389        });
2390        fileReader.readAsDataURL(image);
2391        await imagePromise;
2392      } else {
2393        data.bitmap = await createImageBitmap(image);
2394      }
2395      data.refCounter = 1;
2396    } catch (e) {
2397      warn(e);
2398      data = null;
2399    }
2400    this.#cache.set(key, data);
2401    if (data) {
2402      this.#cache.set(data.id, data);
2403    }
2404    return data;
2405  }
2406  async getFromFile(file) {
2407    const {
2408      lastModified,
2409      name,
2410      size,
2411      type
2412    } = file;
2413    return this.#get(`${lastModified}_${name}_${size}_${type}`, file);
2414  }
2415  async getFromUrl(url) {
2416    return this.#get(url, url);
2417  }
2418  async getFromBlob(id, blobPromise) {
2419    const blob = await blobPromise;
2420    return this.#get(id, blob);
2421  }
2422  async getFromId(id) {
2423    this.#cache ||= new Map();
2424    const data = this.#cache.get(id);
2425    if (!data) {
2426      return null;
2427    }
2428    if (data.bitmap) {
2429      data.refCounter += 1;
2430      return data;
2431    }
2432    if (data.file) {
2433      return this.getFromFile(data.file);
2434    }
2435    if (data.blobPromise) {
2436      const {
2437        blobPromise
2438      } = data;
2439      delete data.blobPromise;
2440      return this.getFromBlob(data.id, blobPromise);
2441    }
2442    return this.getFromUrl(data.url);
2443  }
2444  getFromCanvas(id, canvas) {
2445    this.#cache ||= new Map();
2446    let data = this.#cache.get(id);
2447    if (data?.bitmap) {
2448      data.refCounter += 1;
2449      return data;
2450    }
2451    const offscreen = new OffscreenCanvas(canvas.width, canvas.height);
2452    const ctx = offscreen.getContext("2d");
2453    ctx.drawImage(canvas, 0, 0);
2454    data = {
2455      bitmap: offscreen.transferToImageBitmap(),
2456      id: `image_${this.#baseId}_${this.#id++}`,
2457      refCounter: 1,
2458      isSvg: false
2459    };
2460    this.#cache.set(id, data);
2461    this.#cache.set(data.id, data);
2462    return data;
2463  }
2464  getSvgUrl(id) {
2465    const data = this.#cache.get(id);
2466    if (!data?.isSvg) {
2467      return null;
2468    }
2469    return data.svgUrl;
2470  }
2471  deleteId(id) {
2472    this.#cache ||= new Map();
2473    const data = this.#cache.get(id);
2474    if (!data) {
2475      return;
2476    }
2477    data.refCounter -= 1;
2478    if (data.refCounter !== 0) {
2479      return;
2480    }
2481    const {
2482      bitmap
2483    } = data;
2484    if (!data.url && !data.file) {
2485      const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
2486      const ctx = canvas.getContext("bitmaprenderer");
2487      ctx.transferFromImageBitmap(bitmap);
2488      data.blobPromise = canvas.convertToBlob();
2489    }
2490    bitmap.close?.();
2491    data.bitmap = null;
2492  }
2493  isValidId(id) {
2494    return id.startsWith(`image_${this.#baseId}_`);
2495  }
2496}
2497class CommandManager {
2498  #commands = [];
2499  #locked = false;

2500  #maxSize;
2501  #position = -1;
2502  constructor(maxSize = 128) {
2503    this.#maxSize = maxSize;
2504  }
2505  add({
2506    cmd,
2507    undo,
2508    post,
2509    mustExec,
2510    type = NaN,
2511    overwriteIfSameType = false,
2512    keepUndo = false
2513  }) {
2514    if (mustExec) {
2515      cmd();
2516    }
2517    if (this.#locked) {
2518      return;
2519    }
2520    const save = {
2521      cmd,
2522      undo,
2523      post,
2524      type
2525    };
2526    if (this.#position === -1) {
2527      if (this.#commands.length > 0) {
2528        this.#commands.length = 0;
2529      }
2530      this.#position = 0;
2531      this.#commands.push(save);
2532      return;
2533    }
2534    if (overwriteIfSameType && this.#commands[this.#position].type === type) {
2535      if (keepUndo) {
2536        save.undo = this.#commands[this.#position].undo;
2537      }
2538      this.#commands[this.#position] = save;
2539      return;
2540    }
2541    const next = this.#position + 1;
2542    if (next === this.#maxSize) {
2543      this.#commands.splice(0, 1);
2544    } else {
2545      this.#position = next;
2546      if (next < this.#commands.length) {
2547        this.#commands.splice(next);
2548      }
2549    }
2550    this.#commands.push(save);
2551  }
2552  undo() {
2553    if (this.#position === -1) {
2554      return;
2555    }
2556    this.#locked = true;
2557    const {
2558      undo,
2559      post
2560    } = this.#commands[this.#position];
2561    undo();
2562    post?.();
2563    this.#locked = false;
2564    this.#position -= 1;
2565  }
2566  redo() {
2567    if (this.#position < this.#commands.length - 1) {
2568      this.#position += 1;
2569      this.#locked = true;
2570      const {
2571        cmd,
2572        post
2573      } = this.#commands[this.#position];
2574      cmd();
2575      post?.();
2576      this.#locked = false;
2577    }
2578  }
2579  hasSomethingToUndo() {
2580    return this.#position !== -1;
2581  }
2582  hasSomethingToRedo() {
2583    return this.#position < this.#commands.length - 1;
2584  }
2585  cleanType(type) {
2586    if (this.#position === -1) {
2587      return;
2588    }
2589    for (let i = this.#position; i >= 0; i--) {
2590      if (this.#commands[i].type !== type) {
2591        this.#commands.splice(i + 1, this.#position - i);
2592        this.#position = i;
2593        return;
2594      }
2595    }
2596    this.#commands.length = 0;
2597    this.#position = -1;
2598  }
2599  destroy() {
2600    this.#commands = null;
2601  }
2602}
2603class KeyboardManager {
2604  constructor(callbacks) {
2605    this.buffer = [];
2606    this.callbacks = new Map();
2607    this.allKeys = new Set();
2608    const {
2609      isMac
2610    } = util_FeatureTest.platform;
2611    for (const [keys, callback, options = {}] of callbacks) {
2612      for (const key of keys) {
2613        const isMacKey = key.startsWith("mac+");
2614        if (isMac && isMacKey) {
2615          this.callbacks.set(key.slice(4), {
2616            callback,
2617            options
2618          });
2619          this.allKeys.add(key.split("+").at(-1));
2620        } else if (!isMac && !isMacKey) {
2621          this.callbacks.set(key, {
2622            callback,
2623            options
2624          });
2625          this.allKeys.add(key.split("+").at(-1));
2626        }
2627      }
2628    }
2629  }
2630  #serialize(event) {
2631    if (event.altKey) {
2632      this.buffer.push("alt");
2633    }
2634    if (event.ctrlKey) {
2635      this.buffer.push("ctrl");
2636    }
2637    if (event.metaKey) {
2638      this.buffer.push("meta");
2639    }
2640    if (event.shiftKey) {
2641      this.buffer.push("shift");
2642    }
2643    this.buffer.push(event.key);
2644    const str = this.buffer.join("+");
2645    this.buffer.length = 0;
2646    return str;
2647  }
2648  exec(self, event) {
2649    if (!this.allKeys.has(event.key)) {
2650      return;
2651    }
2652    const info = this.callbacks.get(this.#serialize(event));
2653    if (!info) {
2654      return;
2655    }
2656    const {
2657      callback,
2658      options: {
2659        bubbles = false,
2660        args = [],
2661        checker = null
2662      }
2663    } = info;
2664    if (checker && !checker(self, event)) {
2665      return;
2666    }
2667    callback.bind(self, ...args, event)();
2668    if (!bubbles) {
2669      stopEvent(event);
2670    }
2671  }
2672}
2673class ColorManager {
2674  static _colorsMapping = new Map([["CanvasText", [0, 0, 0]], ["Canvas", [255, 255, 255]]]);
2675  get _colors() {
2676    const colors = new Map([["CanvasText", null], ["Canvas", null]]);
2677    getColorValues(colors);
2678    return shadow(this, "_colors", colors);
2679  }
2680  convert(color) {
2681    const rgb = getRGB(color);
2682    if (!window.matchMedia("(forced-colors: active)").matches) {
2683      return rgb;
2684    }
2685    for (const [name, RGB] of this._colors) {
2686      if (RGB.every((x, i) => x === rgb[i])) {
2687        return ColorManager._colorsMapping.get(name);
2688      }
2689    }
2690    return rgb;
2691  }
2692  getHexCode(name) {
2693    const rgb = this._colors.get(name);
2694    if (!rgb) {
2695      return name;
2696    }
2697    return Util.makeHexColor(...rgb);
2698  }
2699}
2700class AnnotationEditorUIManager {
2701  #abortController = new AbortController();
2702  #activeEditor = null;
2703  #allEditableAnnotations = null;
2704  #allEditors = new Map();
2705  #allLayers = new Map();
2706  #altTextManager = null;
2707  #annotationStorage = null;
2708  #changedExistingAnnotations = null;
2709  #commandManager = new CommandManager();
2710  #commentManager = null;
2711  #copyPasteAC = null;
2712  #currentDrawingSession = null;
2713  #currentPageIndex = 0;
2714  #deletedAnnotationsElementIds = new Set();
2715  #draggingEditors = null;
2716  #editorTypes = null;
2717  #editorsToRescale = new Set();
2718  _editorUndoBar = null;
2719  #enableHighlightFloatingButton = false;
2720  #enableUpdatedAddImage = false;
2721  #enableNewAltTextWhenAddingImage = false;
2722  #filterFactory = null;
2723  #focusMainContainerTimeoutId = null;
2724  #focusManagerAC = null;
2725  #highlightColors = null;
2726  #highlightWhenShiftUp = false;
2727  #floatingToolbar = null;
2728  #idManager = new IdManager();
2729  #isEnabled = false;
2730  #isPointerDown = false;
2731  #isWaiting = false;
2732  #keyboardManagerAC = null;
2733  #lastActiveElement = null;
2734  #mainHighlightColorPicker = null;
2735  #missingCanvases = null;
2736  #mlManager = null;
2737  #mode = AnnotationEditorType.NONE;
2738  #selectedEditors = new Set();
2739  #selectedTextNode = null;
2740  #signatureManager = null;
2741  #pageColors = null;
2742  #showAllStates = null;
2743  #pdfDocument = null;
2744  #previousStates = {
2745    isEditing: false,
2746    isEmpty: true,
2747    hasSomethingToUndo: false,
2748    hasSomethingToRedo: false,
2749    hasSelectedEditor: false,
2750    hasSelectedText: false
2751  };
2752  #translation = [0, 0];
2753  #translationTimeoutId = null;
2754  #container = null;
2755  #viewer = null;
2756  #viewerAlert = null;
2757  #updateModeCapability = null;
2758  static TRANSLATE_SMALL = 1;
2759  static TRANSLATE_BIG = 10;
2760  static get _keyboardManager() {
2761    const proto = AnnotationEditorUIManager.prototype;
2762    const arrowChecker = self => self.#container.contains(document.activeElement) && document.activeElement.tagName !== "BUTTON" && self.hasSomethingToControl();
2763    const textInputChecker = (_self, {
2764      target: el
2765    }) => {
2766      if (el instanceof HTMLInputElement) {
2767        const {
2768          type
2769        } = el;
2770        return type !== "text" && type !== "number";
2771      }
2772      return true;
2773    };
2774    const small = this.TRANSLATE_SMALL;
2775    const big = this.TRANSLATE_BIG;
2776    return shadow(this, "_keyboardManager", new KeyboardManager([[["ctrl+a", "mac+meta+a"], proto.selectAll, {
2777      checker: textInputChecker
2778    }], [["ctrl+z", "mac+meta+z"], proto.undo, {
2779      checker: textInputChecker
2780    }], [["ctrl+y", "ctrl+shift+z", "mac+meta+shift+z", "ctrl+shift+Z", "mac+meta+shift+Z"], proto.redo, {
2781      checker: textInputChecker
2782    }], [["Backspace", "alt+Backspace", "ctrl+Backspace", "shift+Backspace", "mac+Backspace", "mac+alt+Backspace", "mac+ctrl+Backspace", "Delete", "ctrl+Delete", "shift+Delete", "mac+Delete"], proto.delete, {
2783      checker: textInputChecker
2784    }], [["Enter", "mac+Enter"], proto.addNewEditorFromKeyboard, {
2785      checker: (self, {
2786        target: el
2787      }) => !(el instanceof HTMLButtonElement) && self.#container.contains(el) && !self.isEnterHandled
2788    }], [[" ", "mac+ "], proto.addNewEditorFromKeyboard, {
2789      checker: (self, {
2790        target: el
2791      }) => !(el instanceof HTMLButtonElement) && self.#container.contains(document.activeElement)
2792    }], [["Escape", "mac+Escape"], proto.unselectAll], [["ArrowLeft", "mac+ArrowLeft"], proto.translateSelectedEditors, {
2793      args: [-small, 0],
2794      checker: arrowChecker
2795    }], [["ctrl+ArrowLeft", "mac+shift+ArrowLeft"], proto.translateSelectedEditors, {
2796      args: [-big, 0],
2797      checker: arrowChecker
2798    }], [["ArrowRight", "mac+ArrowRight"], proto.translateSelectedEditors, {
2799      args: [small, 0],
2800      checker: arrowChecker
2801    }], [["ctrl+ArrowRight", "mac+shift+ArrowRight"], proto.translateSelectedEditors, {
2802      args: [big, 0],
2803      checker: arrowChecker
2804    }], [["ArrowUp", "mac+ArrowUp"], proto.translateSelectedEditors, {
2805      args: [0, -small],
2806      checker: arrowChecker
2807    }], [["ctrl+ArrowUp", "mac+shift+ArrowUp"], proto.translateSelectedEditors, {
2808      args: [0, -big],
2809      checker: arrowChecker
2810    }], [["ArrowDown", "mac+ArrowDown"], proto.translateSelectedEditors, {
2811      args: [0, small],
2812      checker: arrowChecker
2813    }], [["ctrl+ArrowDown", "mac+shift+ArrowDown"], proto.translateSelectedEditors, {
2814      args: [0, big],
2815      checker: arrowChecker
2816    }]]));
2817  }
2818  constructor(container, viewer, viewerAlert, altTextManager, commentManager, signatureManager, eventBus, pdfDocument, pageColors, highlightColors, enableHighlightFloatingButton, enableUpdatedAddImage, enableNewAltTextWhenAddingImage, mlManager, editorUndoBar, supportsPinchToZoom) {
2819    const signal = this._signal = this.#abortController.signal;
2820    this.#container = container;
2821    this.#viewer = viewer;
2822    this.#viewerAlert = viewerAlert;
2823    this.#altTextManager = altTextManager;
2824    this.#commentManager = commentManager;
2825    this.#signatureManager = signatureManager;
2826    this.#pdfDocument = pdfDocument;
2827    this._eventBus = eventBus;
2828    eventBus._on("editingaction", this.onEditingAction.bind(this), {
2829      signal
2830    });
2831    eventBus._on("pagechanging", this.onPageChanging.bind(this), {
2832      signal
2833    });
2834    eventBus._on("scalechanging", this.onScaleChanging.bind(this), {
2835      signal
2836    });
2837    eventBus._on("rotationchanging", this.onRotationChanging.bind(this), {
2838      signal
2839    });
2840    eventBus._on("setpreference", this.onSetPreference.bind(this), {
2841      signal
2842    });
2843    eventBus._on("switchannotationeditorparams", evt => this.updateParams(evt.type, evt.value), {
2844      signal
2845    });
2846    eventBus._on("pagesedited", this.onPagesEdited.bind(this), {
2847      signal
2848    });
2849    window.addEventListener("pointerdown", () => {
2850      this.#isPointerDown = true;
2851    }, {