https://odoo.pantalytics.com/web/static/lib/pdfjs/build/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/******/ // The require scope
24/******/ var __webpack_require__ = {};
25/******/ 
26/************************************************************************/
27/******/ /* webpack/runtime/define property getters */
28/******/ (() => {
29/******/ 	// define getter functions for harmony exports
30/******/ 	__webpack_require__.d = (exports, definition) => {
31/******/ 		for(var key in definition) {
32/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
33/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
34/******/ 			}
35/******/ 		}
36/******/ 	};
37/******/ })();
38/******/ 
39/******/ /* webpack/runtime/hasOwnProperty shorthand */
40/******/ (() => {
41/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
42/******/ })();
43/******/ 
44/************************************************************************/
45var __webpack_exports__ = globalThis.pdfjsLib = {};
46
47// EXPORTS
48__webpack_require__.d(__webpack_exports__, {
49  AbortException: () => (/* reexport */ AbortException),
50  AnnotationEditorLayer: () => (/* reexport */ AnnotationEditorLayer),
51  AnnotationEditorParamsType: () => (/* reexport */ AnnotationEditorParamsType),
52  AnnotationEditorType: () => (/* reexport */ AnnotationEditorType),
53  AnnotationEditorUIManager: () => (/* reexport */ AnnotationEditorUIManager),
54  AnnotationLayer: () => (/* reexport */ AnnotationLayer),
55  AnnotationMode: () => (/* reexport */ AnnotationMode),
56  ColorPicker: () => (/* reexport */ ColorPicker),
57  DOMSVGFactory: () => (/* reexport */ DOMSVGFactory),
58  DrawLayer: () => (/* reexport */ DrawLayer),
59  FeatureTest: () => (/* reexport */ util_FeatureTest),
60  GlobalWorkerOptions: () => (/* reexport */ GlobalWorkerOptions),
61  ImageKind: () => (/* reexport */ util_ImageKind),
62  InvalidPDFException: () => (/* reexport */ InvalidPDFException),
63  MissingPDFException: () => (/* reexport */ MissingPDFException),
64  OPS: () => (/* reexport */ OPS),
65  OutputScale: () => (/* reexport */ OutputScale),
66  PDFDataRangeTransport: () => (/* reexport */ PDFDataRangeTransport),
67  PDFDateString: () => (/* reexport */ PDFDateString),
68  PDFWorker: () => (/* reexport */ PDFWorker),
69  PasswordResponses: () => (/* reexport */ PasswordResponses),
70  PermissionFlag: () => (/* reexport */ PermissionFlag),
71  PixelsPerInch: () => (/* reexport */ PixelsPerInch),
72  RenderingCancelledException: () => (/* reexport */ RenderingCancelledException),
73  TextLayer: () => (/* reexport */ TextLayer),
74  UnexpectedResponseException: () => (/* reexport */ UnexpectedResponseException),
75  Util: () => (/* reexport */ Util),
76  VerbosityLevel: () => (/* reexport */ VerbosityLevel),
77  XfaLayer: () => (/* reexport */ XfaLayer),
78  build: () => (/* reexport */ build),
79  createValidAbsoluteUrl: () => (/* reexport */ createValidAbsoluteUrl),
80  fetchData: () => (/* reexport */ fetchData),
81  getDocument: () => (/* reexport */ getDocument),
82  getFilenameFromUrl: () => (/* reexport */ getFilenameFromUrl),
83  getPdfFilenameFromUrl: () => (/* reexport */ getPdfFilenameFromUrl),
84  getXfaPageViewport: () => (/* reexport */ getXfaPageViewport),
85  isDataScheme: () => (/* reexport */ isDataScheme),
86  isPdfFile: () => (/* reexport */ isPdfFile),
87  noContextMenu: () => (/* reexport */ noContextMenu),
88  normalizeUnicode: () => (/* reexport */ normalizeUnicode),
89  setLayerDimensions: () => (/* reexport */ setLayerDimensions),
90  shadow: () => (/* reexport */ shadow),
91  version: () => (/* reexport */ version)
92});
93
94;// ./src/shared/util.js
95const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
96const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
97const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
98const MAX_IMAGE_SIZE_TO_CACHE = 10e6;
99const LINE_FACTOR = 1.35;
100const LINE_DESCENT_FACTOR = 0.35;
101const BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
102const RenderingIntentFlag = {
103  ANY: 0x01,
104  DISPLAY: 0x02,
105  PRINT: 0x04,
106  SAVE: 0x08,
107  ANNOTATIONS_FORMS: 0x10,
108  ANNOTATIONS_STORAGE: 0x20,
109  ANNOTATIONS_DISABLE: 0x40,
110  IS_EDITING: 0x80,
111  OPLIST: 0x100
112};
113const AnnotationMode = {
114  DISABLE: 0,
115  ENABLE: 1,
116  ENABLE_FORMS: 2,
117  ENABLE_STORAGE: 3
118};
119const AnnotationEditorPrefix = "pdfjs_internal_editor_";
120const AnnotationEditorType = {
121  DISABLE: -1,
122  NONE: 0,
123  FREETEXT: 3,
124  HIGHLIGHT: 9,
125  STAMP: 13,
126  INK: 15
127};
128const AnnotationEditorParamsType = {
129  RESIZE: 1,
130  CREATE: 2,

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

894    viewBox,
895    scale,
896    rotation,
897    offsetX = 0,
898    offsetY = 0,
899    dontFlip = false
900  }) {
901    this.viewBox = viewBox;
902    this.scale = scale;
903    this.rotation = rotation;
904    this.offsetX = offsetX;
905    this.offsetY = offsetY;
906    const centerX = (viewBox[2] + viewBox[0]) / 2;
907    const centerY = (viewBox[3] + viewBox[1]) / 2;
908    let rotateA, rotateB, rotateC, rotateD;
909    rotation %= 360;
910    if (rotation < 0) {
911      rotation += 360;
912    }
913    switch (rotation) {
914      case 180:
915        rotateA = -1;
916        rotateB = 0;
917        rotateC = 0;
918        rotateD = 1;
919        break;
920      case 90:
921        rotateA = 0;
922        rotateB = 1;
923        rotateC = 1;
924        rotateD = 0;
925        break;
926      case 270:
927        rotateA = 0;
928        rotateB = -1;
929        rotateC = -1;
930        rotateD = 0;
931        break;
932      case 0:
933        rotateA = 1;
934        rotateB = 0;
935        rotateC = 0;
936        rotateD = -1;
937        break;
938      default:
939        throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.");
940    }
941    if (dontFlip) {
942      rotateC = -rotateC;
943      rotateD = -rotateD;
944    }
945    let offsetCanvasX, offsetCanvasY;
946    let width, height;
947    if (rotateA === 0) {
948      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
949      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
950      width = (viewBox[3] - viewBox[1]) * scale;
951      height = (viewBox[2] - viewBox[0]) * scale;
952    } else {
953      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
954      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
955      width = (viewBox[2] - viewBox[0]) * scale;
956      height = (viewBox[3] - viewBox[1]) * scale;
957    }
958    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
959    this.width = width;
960    this.height = height;
961  }
962  get rawDims() {
963    const {
964      viewBox
965    } = this;
966    return shadow(this, "rawDims", {
967      pageWidth: viewBox[2] - viewBox[0],
968      pageHeight: viewBox[3] - viewBox[1],
969      pageX: viewBox[0],
970      pageY: viewBox[1]
971    });
972  }
973  clone({
974    scale = this.scale,
975    rotation = this.rotation,
976    offsetX = this.offsetX,
977    offsetY = this.offsetY,
978    dontFlip = false
979  } = {}) {
980    return new PageViewport({
981      viewBox: this.viewBox.slice(),
982      scale,
983      rotation,
984      offsetX,
985      offsetY,
986      dontFlip
987    });
988  }
989  convertToViewportPoint(x, y) {
990    return Util.applyTransform([x, y], this.transform);
991  }
992  convertToViewportRectangle(rect) {
993    const topLeft = Util.applyTransform([rect[0], rect[1]], this.transform);
994    const bottomRight = Util.applyTransform([rect[2], rect[3]], this.transform);
995    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
996  }
997  convertToPdfPoint(x, y) {
998    return Util.applyInverseTransform([x, y], this.transform);
999  }
1000}
1001class RenderingCancelledException extends BaseException {
1002  constructor(msg, extraDelay = 0) {
1003    super(msg, "RenderingCancelledException");
1004    this.extraDelay = extraDelay;
1005  }
1006}
1007function isDataScheme(url) {
1008  const ii = url.length;
1009  let i = 0;
1010  while (i < ii && url[i].trim() === "") {
1011    i++;
1012  }
1013  return url.substring(i, i + 5).toLowerCase() === "data:";
1014}
1015function isPdfFile(filename) {
1016  return typeof filename === "string" && /\.pdf$/i.test(filename);
1017}
1018function getFilenameFromUrl(url) {
1019  [url] = url.split(/[#?]/, 1);
1020  return url.substring(url.lastIndexOf("/") + 1);
1021}
1022function getPdfFilenameFromUrl(url, defaultFilename = "document.pdf") {
1023  if (typeof url !== "string") {
1024    return defaultFilename;
1025  }
1026  if (isDataScheme(url)) {
1027    warn('getPdfFilenameFromUrl: ignore "data:"-URL for performance reasons.');
1028    return defaultFilename;
1029  }
1030  const reURI = /^(?:(?:[^:]+:)?\/\/[^/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
1031  const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
1032  const splitURI = reURI.exec(url);
1033  let suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
1034  if (suggestedFilename) {
1035    suggestedFilename = suggestedFilename[0];
1036    if (suggestedFilename.includes("%")) {

1111    month = month >= 1 && month <= 12 ? month - 1 : 0;
1112    let day = parseInt(matches[3], 10);
1113    day = day >= 1 && day <= 31 ? day : 1;
1114    let hour = parseInt(matches[4], 10);
1115    hour = hour >= 0 && hour <= 23 ? hour : 0;
1116    let minute = parseInt(matches[5], 10);
1117    minute = minute >= 0 && minute <= 59 ? minute : 0;
1118    let second = parseInt(matches[6], 10);
1119    second = second >= 0 && second <= 59 ? second : 0;
1120    const universalTimeRelation = matches[7] || "Z";
1121    let offsetHour = parseInt(matches[8], 10);
1122    offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
1123    let offsetMinute = parseInt(matches[9], 10) || 0;
1124    offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
1125    if (universalTimeRelation === "-") {
1126      hour += offsetHour;
1127      minute += offsetMinute;
1128    } else if (universalTimeRelation === "+") {
1129      hour -= offsetHour;
1130      minute -= offsetMinute;
1131    }
1132    return new Date(Date.UTC(year, month, day, hour, minute, second));
1133  }
1134}
1135function getXfaPageViewport(xfaPage, {
1136  scale = 1,
1137  rotation = 0
1138}) {
1139  const {
1140    width,
1141    height
1142  } = xfaPage.attributes.style;
1143  const viewBox = [0, 0, parseInt(width), parseInt(height)];
1144  return new PageViewport({
1145    viewBox,
1146    scale,
1147    rotation
1148  });
1149}
1150function getRGB(color) {
1151  if (color.startsWith("#")) {
1152    const colorRGB = parseInt(color.slice(1), 16);
1153    return [(colorRGB & 0xff0000) >> 16, (colorRGB & 0x00ff00) >> 8, colorRGB & 0x0000ff];
1154  }
1155  if (color.startsWith("rgb(")) {
1156    return color.slice(4, -1).split(",").map(x => parseInt(x));
1157  }
1158  if (color.startsWith("rgba(")) {
1159    return color.slice(5, -1).split(",").map(x => parseInt(x)).slice(0, 3);
1160  }
1161  warn(`Not a valid color format: "${color}"`);
1162  return [0, 0, 0];
1163}
1164function getColorValues(colors) {
1165  const span = document.createElement("span");
1166  span.style.visibility = "hidden";
1167  document.body.append(span);
1168  for (const name of colors.keys()) {
1169    span.style.color = name;
1170    const computedColor = window.getComputedStyle(span).color;
1171    colors.set(name, getRGB(computedColor));
1172  }
1173  span.remove();
1174}
1175function getCurrentTransform(ctx) {
1176  const {
1177    a,
1178    b,
1179    c,
1180    d,
1181    e,
1182    f
1183  } = ctx.getTransform();
1184  return [a, b, c, d, e, f];
1185}
1186function getCurrentTransformInverse(ctx) {
1187  const {
1188    a,
1189    b,
1190    c,
1191    d,
1192    e,
1193    f
1194  } = ctx.getTransform().invertSelf();
1195  return [a, b, c, d, e, f];
1196}
1197function setLayerDimensions(div, viewport, mustFlip = false, mustRotate = true) {
1198  if (viewport instanceof PageViewport) {
1199    const {
1200      pageWidth,
1201      pageHeight
1202    } = viewport.rawDims;
1203    const {
1204      style
1205    } = div;
1206    const useRound = util_FeatureTest.isCSSRoundSupported;
1207    const w = `var(--scale-factor) * ${pageWidth}px`,
1208      h = `var(--scale-factor) * ${pageHeight}px`;
1209    const widthStr = useRound ? `round(down, ${w}, var(--scale-round-x, 1px))` : `calc(${w})`,
1210      heightStr = useRound ? `round(down, ${h}, var(--scale-round-y, 1px))` : `calc(${h})`;
1211    if (!mustFlip || viewport.rotation % 180 === 0) {
1212      style.width = widthStr;
1213      style.height = heightStr;
1214    } else {
1215      style.width = heightStr;
1216      style.height = widthStr;
1217    }
1218  }
1219  if (mustRotate) {
1220    div.setAttribute("data-main-rotation", viewport.rotation);
1221  }
1222}
1223class OutputScale {
1224  constructor() {
1225    const pixelRatio = window.devicePixelRatio || 1;
1226    this.sx = pixelRatio;
1227    this.sy = pixelRatio;
1228  }
1229  get scaled() {
1230    return this.sx !== 1 || this.sy !== 1;
1231  }
1232  get symmetric() {
1233    return this.sx === this.sy;
1234  }
1235}
1236
1237;// ./src/display/editor/toolbar.js
1238
1239class EditorToolbar {
1240  #toolbar = null;
1241  #colorPicker = null;
1242  #editor;
1243  #buttons = null;
1244  #altText = null;
1245  static #l10nRemove = null;
1246  constructor(editor) {
1247    this.#editor = editor;
1248    EditorToolbar.#l10nRemove ||= Object.freeze({
1249      freetext: "pdfjs-editor-remove-freetext-button",
1250      highlight: "pdfjs-editor-remove-highlight-button",
1251      ink: "pdfjs-editor-remove-ink-button",
1252      stamp: "pdfjs-editor-remove-stamp-button"
1253    });
1254  }
1255  render() {
1256    const editToolbar = this.#toolbar = document.createElement("div");
1257    editToolbar.classList.add("editToolbar", "hidden");
1258    editToolbar.setAttribute("role", "toolbar");
1259    const signal = this.#editor._uiManager._signal;
1260    editToolbar.addEventListener("contextmenu", noContextMenu, {
1261      signal
1262    });
1263    editToolbar.addEventListener("pointerdown", EditorToolbar.#pointerDown, {

1264      signal
1265    });
1266    const buttons = this.#buttons = document.createElement("div");
1267    buttons.className = "buttons";
1268    editToolbar.append(buttons);
1269    const position = this.#editor.toolbarPosition;
1270    if (position) {
1271      const {
1272        style
1273      } = editToolbar;
1274      const x = this.#editor._uiManager.direction === "ltr" ? 1 - position[0] : position[0];
1275      style.insetInlineEnd = `${100 * x}%`;
1276      style.top = `calc(${100 * position[1]}% + var(--editor-toolbar-vert-offset))`;
1277    }
1278    this.#addDeleteButton();
1279    return editToolbar;
1280  }
1281  get div() {
1282    return this.#toolbar;
1283  }
1284  static #pointerDown(e) {
1285    e.stopPropagation();
1286  }
1287  #focusIn(e) {
1288    this.#editor._focusEventsAllowed = false;
1289    e.preventDefault();
1290    e.stopPropagation();
1291  }
1292  #focusOut(e) {
1293    this.#editor._focusEventsAllowed = true;
1294    e.preventDefault();
1295    e.stopPropagation();
1296  }
1297  #addListenersToElement(element) {
1298    const signal = this.#editor._uiManager._signal;
1299    element.addEventListener("focusin", this.#focusIn.bind(this), {
1300      capture: true,
1301      signal
1302    });
1303    element.addEventListener("focusout", this.#focusOut.bind(this), {
1304      capture: true,
1305      signal
1306    });
1307    element.addEventListener("contextmenu", noContextMenu, {
1308      signal
1309    });
1310  }
1311  hide() {
1312    this.#toolbar.classList.add("hidden");
1313    this.#colorPicker?.hideDropdown();
1314  }
1315  show() {
1316    this.#toolbar.classList.remove("hidden");
1317    this.#altText?.shown();
1318  }
1319  #addDeleteButton() {
1320    const {
1321      editorType,
1322      _uiManager
1323    } = this.#editor;
1324    const button = document.createElement("button");
1325    button.className = "delete";
1326    button.tabIndex = 0;
1327    button.setAttribute("data-l10n-id", EditorToolbar.#l10nRemove[editorType]);
1328    this.#addListenersToElement(button);
1329    button.addEventListener("click", e => {
1330      _uiManager.delete();
1331    }, {
1332      signal: _uiManager._signal
1333    });
1334    this.#buttons.append(button);
1335  }
1336  get #divider() {
1337    const divider = document.createElement("div");
1338    divider.className = "divider";
1339    return divider;
1340  }
1341  async addAltText(altText) {
1342    const button = await altText.render();
1343    this.#addListenersToElement(button);
1344    this.#buttons.prepend(button, this.#divider);
1345    this.#altText = altText;
1346  }
1347  addColorPicker(colorPicker) {
1348    this.#colorPicker = colorPicker;
1349    const button = colorPicker.renderButton();
1350    this.#addListenersToElement(button);
1351    this.#buttons.prepend(button, this.#divider);
1352  }
1353  remove() {
1354    this.#toolbar.remove();
1355    this.#colorPicker?.destroy();
1356    this.#colorPicker = null;
1357  }
1358}
1359class HighlightToolbar {
1360  #buttons = null;
1361  #toolbar = null;
1362  #uiManager;
1363  constructor(uiManager) {
1364    this.#uiManager = uiManager;
1365  }
1366  #render() {
1367    const editToolbar = this.#toolbar = document.createElement("div");
1368    editToolbar.className = "editToolbar";
1369    editToolbar.setAttribute("role", "toolbar");
1370    editToolbar.addEventListener("contextmenu", noContextMenu, {
1371      signal: this.#uiManager._signal
1372    });
1373    const buttons = this.#buttons = document.createElement("div");
1374    buttons.className = "buttons";
1375    editToolbar.append(buttons);
1376    this.#addHighlightButton();
1377    return editToolbar;
1378  }
1379  #getLastPoint(boxes, isLTR) {
1380    let lastY = 0;
1381    let lastX = 0;
1382    for (const box of boxes) {
1383      const y = box.y + box.height;
1384      if (y < lastY) {
1385        continue;
1386      }
1387      const x = box.x + (isLTR ? box.width : 0);
1388      if (y > lastY) {
1389        lastX = x;
1390        lastY = y;
1391        continue;
1392      }
1393      if (isLTR) {
1394        if (x > lastX) {
1395          lastX = x;
1396        }
1397      } else if (x < lastX) {
1398        lastX = x;
1399      }
1400    }
1401    return [isLTR ? 1 - lastX : lastX, lastY];
1402  }
1403  show(parent, boxes, isLTR) {
1404    const [x, y] = this.#getLastPoint(boxes, isLTR);
1405    const {
1406      style
1407    } = this.#toolbar ||= this.#render();
1408    parent.append(this.#toolbar);
1409    style.insetInlineEnd = `${100 * x}%`;
1410    style.top = `calc(${100 * y}% + var(--editor-toolbar-vert-offset))`;
1411  }
1412  hide() {
1413    this.#toolbar.remove();
1414  }
1415  #addHighlightButton() {
1416    const button = document.createElement("button");
1417    button.className = "highlightButton";
1418    button.tabIndex = 0;
1419    button.setAttribute("data-l10n-id", `pdfjs-highlight-floating-button1`);
1420    const span = document.createElement("span");
1421    button.append(span);
1422    span.className = "visuallyHidden";
1423    span.setAttribute("data-l10n-id", "pdfjs-highlight-floating-button-label");
1424    const signal = this.#uiManager._signal;
1425    button.addEventListener("contextmenu", noContextMenu, {
1426      signal
1427    });
1428    button.addEventListener("click", () => {
1429      this.#uiManager.highlightSelection("floating_button");
1430    }, {
1431      signal
1432    });
1433    this.#buttons.append(button);
1434  }
1435}
1436
1437;// ./src/display/editor/tools.js
1438
1439
1440
1441function bindEvents(obj, element, names) {
1442  for (const name of names) {
1443    element.addEventListener(name, obj[name].bind(obj));
1444  }
1445}
1446function opacityToHex(opacity) {
1447  return Math.round(Math.min(255, Math.max(1, 255 * opacity))).toString(16).padStart(2, "0");
1448}
1449class IdManager {
1450  #id = 0;
1451  get id() {
1452    return `${AnnotationEditorPrefix}${this.#id++}`;
1453  }
1454}
1455class ImageManager {
1456  #baseId = getUuid();
1457  #id = 0;
1458  #cache = null;
1459  static get _isSVGFittingCanvas() {
1460    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>`;
1461    const canvas = new OffscreenCanvas(1, 3);
1462    const ctx = canvas.getContext("2d", {
1463      willReadFrequently: true
1464    });
1465    const image = new Image();
1466    image.src = svg;
1467    const promise = image.decode().then(() => {
1468      ctx.drawImage(image, 0, 0, 1, 1, 0, 0, 1, 3);
1469      return new Uint32Array(ctx.getImageData(0, 0, 1, 1).data.buffer)[0] === 0;
1470    });
1471    return shadow(this, "_isSVGFittingCanvas", promise);
1472  }
1473  async #get(key, rawData) {
1474    this.#cache ||= new Map();
1475    let data = this.#cache.get(key);
1476    if (data === null) {
1477      return null;
1478    }
1479    if (data?.bitmap) {
1480      data.refCounter += 1;
1481      return data;
1482    }
1483    try {
1484      data ||= {
1485        bitmap: null,
1486        id: `image_${this.#baseId}_${this.#id++}`,
1487        refCounter: 0,
1488        isSvg: false
1489      };
1490      let image;
1491      if (typeof rawData === "string") {
1492        data.url = rawData;
1493        image = await fetchData(rawData, "blob");
1494      } else if (rawData instanceof File) {
1495        image = data.file = rawData;
1496      } else if (rawData instanceof Blob) {
1497        image = rawData;
1498      }
1499      if (image.type === "image/svg+xml") {
1500        const mustRemoveAspectRatioPromise = ImageManager._isSVGFittingCanvas;
1501        const fileReader = new FileReader();
1502        const imageElement = new Image();
1503        const imagePromise = new Promise((resolve, reject) => {
1504          imageElement.onload = () => {
1505            data.bitmap = imageElement;
1506            data.isSvg = true;
1507            resolve();
1508          };
1509          fileReader.onload = async () => {
1510            const url = data.svgUrl = fileReader.result;
1511            imageElement.src = (await mustRemoveAspectRatioPromise) ? `${url}#svgView(preserveAspectRatio(none))` : url;
1512          };
1513          imageElement.onerror = fileReader.onerror = reject;
1514        });
1515        fileReader.readAsDataURL(image);
1516        await imagePromise;
1517      } else {
1518        data.bitmap = await createImageBitmap(image);
1519      }
1520      data.refCounter = 1;
1521    } catch (e) {
1522      console.error(e);
1523      data = null;
1524    }
1525    this.#cache.set(key, data);
1526    if (data) {
1527      this.#cache.set(data.id, data);
1528    }
1529    return data;
1530  }
1531  async getFromFile(file) {
1532    const {
1533      lastModified,
1534      name,
1535      size,
1536      type
1537    } = file;
1538    return this.#get(`${lastModified}_${name}_${size}_${type}`, file);
1539  }
1540  async getFromUrl(url) {
1541    return this.#get(url, url);
1542  }
1543  async getFromBlob(id, blobPromise) {
1544    const blob = await blobPromise;
1545    return this.#get(id, blob);
1546  }
1547  async getFromId(id) {
1548    this.#cache ||= new Map();
1549    const data = this.#cache.get(id);
1550    if (!data) {
1551      return null;
1552    }
1553    if (data.bitmap) {
1554      data.refCounter += 1;
1555      return data;
1556    }
1557    if (data.file) {
1558      return this.getFromFile(data.file);
1559    }
1560    if (data.blobPromise) {
1561      const {
1562        blobPromise
1563      } = data;
1564      delete data.blobPromise;
1565      return this.getFromBlob(data.id, blobPromise);
1566    }
1567    return this.getFromUrl(data.url);
1568  }
1569  getFromCanvas(id, canvas) {
1570    this.#cache ||= new Map();
1571    let data = this.#cache.get(id);
1572    if (data?.bitmap) {
1573      data.refCounter += 1;
1574      return data;
1575    }
1576    const offscreen = new OffscreenCanvas(canvas.width, canvas.height);
1577    const ctx = offscreen.getContext("2d");
1578    ctx.drawImage(canvas, 0, 0);
1579    data = {
1580      bitmap: offscreen.transferToImageBitmap(),
1581      id: `image_${this.#baseId}_${this.#id++}`,
1582      refCounter: 1,
1583      isSvg: false
1584    };
1585    this.#cache.set(id, data);
1586    this.#cache.set(data.id, data);
1587    return data;
1588  }
1589  getSvgUrl(id) {
1590    const data = this.#cache.get(id);
1591    if (!data?.isSvg) {
1592      return null;
1593    }
1594    return data.svgUrl;
1595  }
1596  deleteId(id) {
1597    this.#cache ||= new Map();
1598    const data = this.#cache.get(id);
1599    if (!data) {
1600      return;
1601    }
1602    data.refCounter -= 1;
1603    if (data.refCounter !== 0) {
1604      return;
1605    }
1606    const {
1607      bitmap
1608    } = data;
1609    if (!data.url && !data.file) {
1610      const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
1611      const ctx = canvas.getContext("bitmaprenderer");
1612      ctx.transferFromImageBitmap(bitmap);
1613      data.blobPromise = canvas.convertToBlob();
1614    }
1615    bitmap.close?.();
1616    data.bitmap = null;
1617  }
1618  isValidId(id) {
1619    return id.startsWith(`image_${this.#baseId}_`);
1620  }
1621}
1622class CommandManager {
1623  #commands = [];
1624  #locked = false;
1625  #maxSize;
1626  #position = -1;
1627  constructor(maxSize = 128) {
1628    this.#maxSize = maxSize;
1629  }
1630  add({
1631    cmd,
1632    undo,
1633    post,
1634    mustExec,
1635    type = NaN,
1636    overwriteIfSameType = false,
1637    keepUndo = false
1638  }) {
1639    if (mustExec) {
1640      cmd();
1641    }
1642    if (this.#locked) {
1643      return;
1644    }
1645    const save = {
1646      cmd,
1647      undo,
1648      post,
1649      type
1650    };
1651    if (this.#position === -1) {
1652      if (this.#commands.length > 0) {
1653        this.#commands.length = 0;
1654      }
1655      this.#position = 0;
1656      this.#commands.push(save);
1657      return;
1658    }
1659    if (overwriteIfSameType && this.#commands[this.#position].type === type) {
1660      if (keepUndo) {
1661        save.undo = this.#commands[this.#position].undo;
1662      }
1663      this.#commands[this.#position] = save;
1664      return;
1665    }
1666    const next = this.#position + 1;
1667    if (next === this.#maxSize) {
1668      this.#commands.splice(0, 1);
1669    } else {
1670      this.#position = next;
1671      if (next < this.#commands.length) {
1672        this.#commands.splice(next);
1673      }
1674    }
1675    this.#commands.push(save);
1676  }
1677  undo() {
1678    if (this.#position === -1) {
1679      return;
1680    }
1681    this.#locked = true;
1682    const {
1683      undo,
1684      post
1685    } = this.#commands[this.#position];
1686    undo();
1687    post?.();
1688    this.#locked = false;
1689    this.#position -= 1;
1690  }
1691  redo() {
1692    if (this.#position < this.#commands.length - 1) {
1693      this.#position += 1;
1694      this.#locked = true;
1695      const {
1696        cmd,
1697        post
1698      } = this.#commands[this.#position];
1699      cmd();
1700      post?.();
1701      this.#locked = false;

1702    }
1703  }
1704  hasSomethingToUndo() {
1705    return this.#position !== -1;
1706  }
1707  hasSomethingToRedo() {
1708    return this.#position < this.#commands.length - 1;
1709  }
1710  destroy() {
1711    this.#commands = null;
1712  }
1713}
1714class KeyboardManager {
1715  constructor(callbacks) {
1716    this.buffer = [];
1717    this.callbacks = new Map();
1718    this.allKeys = new Set();
1719    const {
1720      isMac
1721    } = util_FeatureTest.platform;
1722    for (const [keys, callback, options = {}] of callbacks) {
1723      for (const key of keys) {
1724        const isMacKey = key.startsWith("mac+");
1725        if (isMac && isMacKey) {
1726          this.callbacks.set(key.slice(4), {
1727            callback,
1728            options
1729          });
1730          this.allKeys.add(key.split("+").at(-1));
1731        } else if (!isMac && !isMacKey) {
1732          this.callbacks.set(key, {
1733            callback,
1734            options
1735          });
1736          this.allKeys.add(key.split("+").at(-1));
1737        }
1738      }
1739    }
1740  }
1741  #serialize(event) {
1742    if (event.altKey) {
1743      this.buffer.push("alt");
1744    }
1745    if (event.ctrlKey) {
1746      this.buffer.push("ctrl");
1747    }
1748    if (event.metaKey) {
1749      this.buffer.push("meta");
1750    }
1751    if (event.shiftKey) {
1752      this.buffer.push("shift");
1753    }
1754    this.buffer.push(event.key);
1755    const str = this.buffer.join("+");
1756    this.buffer.length = 0;
1757    return str;
1758  }
1759  exec(self, event) {
1760    if (!this.allKeys.has(event.key)) {
1761      return;
1762    }
1763    const info = this.callbacks.get(this.#serialize(event));
1764    if (!info) {
1765      return;
1766    }
1767    const {
1768      callback,
1769      options: {
1770        bubbles = false,
1771        args = [],
1772        checker = null
1773      }
1774    } = info;
1775    if (checker && !checker(self, event)) {
1776      return;
1777    }
1778    callback.bind(self, ...args, event)();
1779    if (!bubbles) {
1780      event.stopPropagation();
1781      event.preventDefault();
1782    }
1783  }
1784}
1785class ColorManager {
1786  static _colorsMapping = new Map([["CanvasText", [0, 0, 0]], ["Canvas", [255, 255, 255]]]);
1787  get _colors() {
1788    const colors = new Map([["CanvasText", null], ["Canvas", null]]);
1789    getColorValues(colors);
1790    return shadow(this, "_colors", colors);
1791  }
1792  convert(color) {
1793    const rgb = getRGB(color);
1794    if (!window.matchMedia("(forced-colors: active)").matches) {
1795      return rgb;
1796    }
1797    for (const [name, RGB] of this._colors) {
1798      if (RGB.every((x, i) => x === rgb[i])) {
1799        return ColorManager._colorsMapping.get(name);
1800      }
1801    }
1802    return rgb;
1803  }
1804  getHexCode(name) {
1805    const rgb = this._colors.get(name);
1806    if (!rgb) {
1807      return name;
1808    }
1809    return Util.makeHexColor(...rgb);
1810  }
1811}
1812class AnnotationEditorUIManager {
1813  #abortController = new AbortController();
1814  #activeEditor = null;
1815  #allEditors = new Map();
1816  #allLayers = new Map();
1817  #altTextManager = null;
1818  #annotationStorage = null;
1819  #changedExistingAnnotations = null;
1820  #commandManager = new CommandManager();
1821  #copyPasteAC = null;
1822  #currentPageIndex = 0;
1823  #deletedAnnotationsElementIds = new Set();
1824  #draggingEditors = null;
1825  #editorTypes = null;
1826  #editorsToRescale = new Set();
1827  #enableHighlightFloatingButton = false;
1828  #enableUpdatedAddImage = false;
1829  #enableNewAltTextWhenAddingImage = false;
1830  #filterFactory = null;
1831  #focusMainContainerTimeoutId = null;
1832  #focusManagerAC = null;
1833  #highlightColors = null;
1834  #highlightWhenShiftUp = false;
1835  #highlightToolbar = null;
1836  #idManager = new IdManager();
1837  #isEnabled = false;
1838  #isWaiting = false;
1839  #keyboardManagerAC = null;
1840  #lastActiveElement = null;
1841  #mainHighlightColorPicker = null;
1842  #mlManager = null;
1843  #mode = AnnotationEditorType.NONE;
1844  #selectedEditors = new Set();
1845  #selectedTextNode = null;
1846  #pageColors = null;
1847  #showAllStates = null;
1848  #previousStates = {
1849    isEditing: false,
1850    isEmpty: true,
1851    hasSomethingToUndo: false,
1852    hasSomethingToRedo: false,
1853    hasSelectedEditor: false,
1854    hasSelectedText: false
1855  };
1856  #translation = [0, 0];
1857  #translationTimeoutId = null;
1858  #container = null;
1859  #viewer = null;
1860  #updateModeCapability = null;
1861  static TRANSLATE_SMALL = 1;
1862  static TRANSLATE_BIG = 10;
1863  static get _keyboardManager() {
1864    const proto = AnnotationEditorUIManager.prototype;
1865    const arrowChecker = self => self.#container.contains(document.activeElement) && document.activeElement.tagName !== "BUTTON" && self.hasSomethingToControl();
1866    const textInputChecker = (_self, {
1867      target: el
1868    }) => {
1869      if (el instanceof HTMLInputElement) {
1870        const {
1871          type
1872        } = el;
1873        return type !== "text" && type !== "number";
1874      }
1875      return true;
1876    };
1877    const small = this.TRANSLATE_SMALL;
1878    const big = this.TRANSLATE_BIG;
1879    return shadow(this, "_keyboardManager", new KeyboardManager([[["ctrl+a", "mac+meta+a"], proto.selectAll, {
1880      checker: textInputChecker
1881    }], [["ctrl+z", "mac+meta+z"], proto.undo, {
1882      checker: textInputChecker
1883    }], [["ctrl+y", "ctrl+shift+z", "mac+meta+shift+z", "ctrl+shift+Z", "mac+meta+shift+Z"], proto.redo, {
1884      checker: textInputChecker
1885    }], [["Backspace", "alt+Backspace", "ctrl+Backspace", "shift+Backspace", "mac+Backspace", "mac+alt+Backspace", "mac+ctrl+Backspace", "Delete", "ctrl+Delete", "shift+Delete", "mac+Delete"], proto.delete, {
1886      checker: textInputChecker
1887    }], [["Enter", "mac+Enter"], proto.addNewEditorFromKeyboard, {
1888      checker: (self, {
1889        target: el
1890      }) => !(el instanceof HTMLButtonElement) && self.#container.contains(el) && !self.isEnterHandled
1891    }], [[" ", "mac+ "], proto.addNewEditorFromKeyboard, {
1892      checker: (self, {
1893        target: el
1894      }) => !(el instanceof HTMLButtonElement) && self.#container.contains(document.activeElement)
1895    }], [["Escape", "mac+Escape"], proto.unselectAll], [["ArrowLeft", "mac+ArrowLeft"], proto.translateSelectedEditors, {
1896      args: [-small, 0],
1897      checker: arrowChecker
1898    }], [["ctrl+ArrowLeft", "mac+shift+ArrowLeft"], proto.translateSelectedEditors, {
1899      args: [-big, 0],
1900      checker: arrowChecker
1901    }], [["ArrowRight", "mac+ArrowRight"], proto.translateSelectedEditors, {
1902      args: [small, 0],
1903      checker: arrowChecker
1904    }], [["ctrl+ArrowRight", "mac+shift+ArrowRight"], proto.translateSelectedEditors, {
1905      args: [big, 0],
1906      checker: arrowChecker
1907    }], [["ArrowUp", "mac+ArrowUp"], proto.translateSelectedEditors, {
1908      args: [0, -small],
1909      checker: arrowChecker
1910    }], [["ctrl+ArrowUp", "mac+shift+ArrowUp"], proto.translateSelectedEditors, {
1911      args: [0, -big],
1912      checker: arrowChecker
1913    }], [["ArrowDown", "mac+ArrowDown"], proto.translateSelectedEditors, {
1914      args: [0, small],
1915      checker: arrowChecker
1916    }], [["ctrl+ArrowDown", "mac+shift+ArrowDown"], proto.translateSelectedEditors, {
1917      args: [0, big],
1918      checker: arrowChecker
1919    }]]));
1920  }
1921  constructor(container, viewer, altTextManager, eventBus, pdfDocument, pageColors, highlightColors, enableHighlightFloatingButton, enableUpdatedAddImage, enableNewAltTextWhenAddingImage, mlManager) {
1922    const signal = this._signal = this.#abortController.signal;
1923    this.#container = container;
1924    this.#viewer = viewer;
1925    this.#altTextManager = altTextManager;
1926    this._eventBus = eventBus;
1927    eventBus._on("editingaction", this.onEditingAction.bind(this), {
1928      signal
1929    });
1930    eventBus._on("pagechanging", this.onPageChanging.bind(this), {
1931      signal
1932    });
1933    eventBus._on("scalechanging", this.onScaleChanging.bind(this), {
1934      signal
1935    });
1936    eventBus._on("rotationchanging", this.onRotationChanging.bind(this), {
1937      signal
1938    });
1939    eventBus._on("setpreference", this.onSetPreference.bind(this), {
1940      signal
1941    });
1942    eventBus._on("switchannotationeditorparams", evt => this.updateParams(evt.type, evt.value), {
1943      signal
1944    });
1945    this.#addSelectionListener();
1946    this.#addDragAndDropListeners();
1947    this.#addKeyboardManager();
1948    this.#annotationStorage = pdfDocument.annotationStorage;
1949    this.#filterFactory = pdfDocument.filterFactory;

1950    this.#pageColors = pageColors;
1951    this.#highlightColors = highlightColors || null;
1952    this.#enableHighlightFloatingButton = enableHighlightFloatingButton;
1953    this.#enableUpdatedAddImage = enableUpdatedAddImage;
1954    this.#enableNewAltTextWhenAddingImage = enableNewAltTextWhenAddingImage;
1955    this.#mlManager = mlManager || null;
1956    this.viewParameters = {
1957      realScale: PixelsPerInch.PDF_TO_CSS_UNITS,
1958      rotation: 0
1959    };
1960    this.isShiftKeyDown = false;
1961  }
1962  destroy() {
1963    this.#updateModeCapability?.resolve();
1964    this.#updateModeCapability = null;
1965    this.#abortController?.abort();
1966    this.#abortController = null;
1967    this._signal = null;
1968    for (const layer of this.#allLayers.values()) {
1969      layer.destroy();
1970    }
1971    this.#allLayers.clear();
1972    this.#allEditors.clear();
1973    this.#editorsToRescale.clear();
1974    this.#activeEditor = null;
1975    this.#selectedEditors.clear();
1976    this.#commandManager.destroy();
1977    this.#altTextManager?.destroy();
1978    this.#highlightToolbar?.hide();
1979    this.#highlightToolbar = null;
1980    if (this.#focusMainContainerTimeoutId) {
1981      clearTimeout(this.#focusMainContainerTimeoutId);
1982      this.#focusMainContainerTimeoutId = null;
1983    }
1984    if (this.#translationTimeoutId) {
1985      clearTimeout(this.#translationTimeoutId);
1986      this.#translationTimeoutId = null;
1987    }
1988  }
1989  combinedSignal(ac) {
1990    return AbortSignal.any([this._signal, ac.signal]);
1991  }
1992  get mlManager() {
1993    return this.#mlManager;
1994  }
1995  get useNewAltTextFlow() {
1996    return this.#enableUpdatedAddImage;
1997  }
1998  get useNewAltTextWhenAddingImage() {
1999    return this.#enableNewAltTextWhenAddingImage;
2000  }
2001  get hcmFilter() {
2002    return shadow(this, "hcmFilter", this.#pageColors ? this.#filterFactory.addHCMFilter(this.#pageColors.foreground, this.#pageColors.background) : "none");
2003  }
2004  get direction() {
2005    return shadow(this, "direction", getComputedStyle(this.#container).direction);
2006  }
2007  get highlightColors() {
2008    return shadow(this, "highlightColors", this.#highlightColors ? new Map(this.#highlightColors.split(",").map(pair => pair.split("=").map(x => x.trim()))) : null);
2009  }
2010  get highlightColorNames() {
2011    return shadow(this, "highlightColorNames", this.highlightColors ? new Map(Array.from(this.highlightColors, e => e.reverse())) : null);
2012  }
2013  setMainHighlightColorPicker(colorPicker) {
2014    this.#mainHighlightColorPicker = colorPicker;
2015  }
2016  editAltText(editor, firstTime = false) {
2017    this.#altTextManager?.editAltText(this, editor, firstTime);
2018  }
2019  switchToMode(mode, callback) {
2020    this._eventBus.on("annotationeditormodechanged", callback, {
2021      once: true,
2022      signal: this._signal
2023    });
2024    this._eventBus.dispatch("showannotationeditorui", {
2025      source: this,
2026      mode
2027    });
2028  }
2029  setPreference(name, value) {
2030    this._eventBus.dispatch("setpreference", {
2031      source: this,
2032      name,
2033      value
2034    });
2035  }
2036  onSetPreference({
2037    name,
2038    value
2039  }) {
2040    switch (name) {
2041      case "enableNewAltTextWhenAddingImage":
2042        this.#enableNewAltTextWhenAddingImage = value;
2043        break;
2044    }
2045  }
2046  onPageChanging({
2047    pageNumber
2048  }) {
2049    this.#currentPageIndex = pageNumber - 1;
2050  }
2051  focusMainContainer() {
2052    this.#container.focus();
2053  }
2054  findParent(x, y) {
2055    for (const layer of this.#allLayers.values()) {
2056      const {
2057        x: layerX,
2058        y: layerY,
2059        width,
2060        height
2061      } = layer.div.getBoundingClientRect();
2062      if (x >= layerX && x <= layerX + width && y >= layerY && y <= layerY + height) {
2063        return layer;
2064      }
2065    }
2066    return null;
2067  }
2068  disableUserSelect(value = false) {
2069    this.#viewer.classList.toggle("noUserSelect", value);
2070  }
2071  addShouldRescale(editor) {
2072    this.#editorsToRescale.add(editor);
2073  }
2074  removeShouldRescale(editor) {
2075    this.#editorsToRescale.delete(editor);
2076  }
2077  onScaleChanging({
2078    scale
2079  }) {
2080    this.commitOrRemove();
2081    this.viewParameters.realScale = scale * PixelsPerInch.PDF_TO_CSS_UNITS;
2082    for (const editor of this.#editorsToRescale) {
2083      editor.onScaleChanging();
2084    }
2085  }
2086  onRotationChanging({
2087    pagesRotation
2088  }) {
2089    this.commitOrRemove();
2090    this.viewParameters.rotation = pagesRotation;
2091  }
2092  #getAnchorElementForSelection({
2093    anchorNode
2094  }) {
2095    return anchorNode.nodeType === Node.TEXT_NODE ? anchorNode.parentElement : anchorNode;
2096  }
2097  #getLayerForTextLayer(textLayer) {
2098    const {
2099      currentLayer
2100    } = this;
2101    if (currentLayer.hasTextLayer(textLayer)) {
2102      return currentLayer;
2103    }
2104    for (const layer of this.#allLayers.values()) {
2105      if (layer.hasTextLayer(textLayer)) {
2106        return layer;
2107      }
2108    }
2109    return null;
2110  }
2111  highlightSelection(methodOfCreation = "") {
2112    const selection = document.getSelection();
2113    if (!selection || selection.isCollapsed) {
2114      return;
2115    }
2116    const {
2117      anchorNode,
2118      anchorOffset,
2119      focusNode,
2120      focusOffset
2121    } = selection;
2122    const text = selection.toString();
2123    const anchorElement = this.#getAnchorElementForSelection(selection);
2124    const textLayer = anchorElement.closest(".textLayer");
2125    const boxes = this.getSelectionBoxes(textLayer);
2126    if (!boxes) {
2127      return;
2128    }
2129    selection.empty();
2130    const layer = this.#getLayerForTextLayer(textLayer);
2131    const isNoneMode = this.#mode === AnnotationEditorType.NONE;
2132    const callback = () => {
2133      layer?.createAndAddNewEditor({
2134        x: 0,
2135        y: 0
2136      }, false, {
2137        methodOfCreation,
2138        boxes,
2139        anchorNode,
2140        anchorOffset,
2141        focusNode,
2142        focusOffset,
2143        text
2144      });
2145      if (isNoneMode) {
2146        this.showAllEditors("highlight", true, true);
2147      }
2148    };
2149    if (isNoneMode) {
2150      this.switchToMode(AnnotationEditorType.HIGHLIGHT, callback);
2151      return;
2152    }
2153    callback();
2154  }
2155  #displayHighlightToolbar() {
2156    const selection = document.getSelection();
2157    if (!selection || selection.isCollapsed) {
2158      return;
2159    }
2160    const anchorElement = this.#getAnchorElementForSelection(selection);
2161    const textLayer = anchorElement.closest(".textLayer");
2162    const boxes = this.getSelectionBoxes(textLayer);
2163    if (!boxes) {
2164      return;
2165    }
2166    this.#highlightToolbar ||= new HighlightToolbar(this);
2167    this.#highlightToolbar.show(textLayer, boxes, this.direction === "ltr");
2168  }
2169  addToAnnotationStorage(editor) {
2170    if (!editor.isEmpty() && this.#annotationStorage && !this.#annotationStorage.has(editor.id)) {
2171      this.#annotationStorage.setValue(editor.id, editor);
2172    }
2173  }
2174  #selectionChange() {
2175    const selection = document.getSelection();
2176    if (!selection || selection.isCollapsed) {
2177      if (this.#selectedTextNode) {
2178        this.#highlightToolbar?.hide();
2179        this.#selectedTextNode = null;
2180        this.#dispatchUpdateStates({
2181          hasSelectedText: false
2182        });
2183      }
2184      return;
2185    }
2186    const {
2187      anchorNode
2188    } = selection;
2189    if (anchorNode === this.#selectedTextNode) {
2190      return;
2191    }
2192    const anchorElement = this.#getAnchorElementForSelection(selection);
2193    const textLayer = anchorElement.closest(".textLayer");
2194    if (!textLayer) {
2195      if (this.#selectedTextNode) {
2196        this.#highlightToolbar?.hide();
2197        this.#selectedTextNode = null;
2198        this.#dispatchUpdateStates({
2199          hasSelectedText: false
2200        });
2201      }
2202      return;
2203    }
2204    this.#highlightToolbar?.hide();
2205    this.#selectedTextNode = anchorNode;
2206    this.#dispatchUpdateStates({
2207      hasSelectedText: true
2208    });
2209    if (this.#mode !== AnnotationEditorType.HIGHLIGHT && this.#mode !== AnnotationEditorType.NONE) {
2210      return;
2211    }
2212    if (this.#mode === AnnotationEditorType.HIGHLIGHT) {
2213      this.showAllEditors("highlight", true, true);
2214    }
2215    this.#highlightWhenShiftUp = this.isShiftKeyDown;
2216    if (!this.isShiftKeyDown) {
2217      const activeLayer = this.#mode === AnnotationEditorType.HIGHLIGHT ? this.#getLayerForTextLayer(textLayer) : null;
2218      activeLayer?.toggleDrawing();
2219      const ac = new AbortController();
2220      const signal = this.combinedSignal(ac);
2221      const pointerup = e => {
2222        if (e.type === "pointerup" && e.button !== 0) {
2223          return;
2224        }
2225        ac.abort();
2226        activeLayer?.toggleDrawing(true);
2227        if (e.type === "pointerup") {
2228          this.#onSelectEnd("main_toolbar");
2229        }
2230      };
2231      window.addEventListener("pointerup", pointerup, {
2232        signal
2233      });
2234      window.addEventListener("blur", pointerup, {
2235        signal
2236      });
2237    }
2238  }
2239  #onSelectEnd(methodOfCreation = "") {
2240    if (this.#mode === AnnotationEditorType.HIGHLIGHT) {
2241      this.highlightSelection(methodOfCreation);
2242    } else if (this.#enableHighlightFloatingButton) {
2243      this.#displayHighlightToolbar();
2244    }
2245  }
2246  #addSelectionListener() {
2247    document.addEventListener("selectionchange", this.#selectionChange.bind(this), {
2248      signal: this._signal
2249    });
2250  }
2251  #addFocusManager() {
2252    if (this.#focusManagerAC) {
2253      return;
2254    }
2255    this.#focusManagerAC = new AbortController();
2256    const signal = this.combinedSignal(this.#focusManagerAC);
2257    window.addEventListener("focus", this.focus.bind(this), {
2258      signal
2259    });
2260    window.addEventListener("blur", this.blur.bind(this), {
2261      signal
2262    });
2263  }
2264  #removeFocusManager() {
2265    this.#focusManagerAC?.abort();
2266    this.#focusManagerAC = null;
2267  }
2268  blur() {
2269    this.isShiftKeyDown = false;

2270    if (this.#highlightWhenShiftUp) {
2271      this.#highlightWhenShiftUp = false;
2272      this.#onSelectEnd("main_toolbar");
2273    }
2274    if (!this.hasSelection) {
2275      return;
2276    }
2277    const {
2278      activeElement
2279    } = document;
2280    for (const editor of this.#selectedEditors) {
2281      if (editor.div.contains(activeElement)) {
2282        this.#lastActiveElement = [editor, activeElement];
2283        editor._focusEventsAllowed = false;
2284        break;
2285      }
2286    }
2287  }
2288  focus() {
2289    if (!this.#lastActiveElement) {
2290      return;
2291    }
2292    const [lastEditor, lastActiveElement] = this.#lastActiveElement;
2293    this.#lastActiveElement = null;
2294    lastActiveElement.addEventListener("focusin", () => {
2295      lastEditor._focusEventsAllowed = true;
2296    }, {
2297      once: true,
2298      signal: this._signal
2299    });
2300    lastActiveElement.focus();
2301  }
2302  #addKeyboardManager() {
2303    if (this.#keyboardManagerAC) {
2304      return;
2305    }
2306    this.#keyboardManagerAC = new AbortController();
2307    const signal = this.combinedSignal(this.#keyboardManagerAC);
2308    window.addEventListener("keydown", this.keydown.bind(this), {
2309      signal
2310    });
2311    window.addEventListener("keyup", this.keyup.bind(this), {
2312      signal
2313    });
2314  }
2315  #removeKeyboardManager() {
2316    this.#keyboardManagerAC?.abort();
2317    this.#keyboardManagerAC = null;
2318  }
2319  #addCopyPasteListeners() {
2320    if (this.#copyPasteAC) {
2321      return;
2322    }
2323    this.#copyPasteAC = new AbortController();
2324    const signal = this.combinedSignal(this.#copyPasteAC);
2325    document.addEventListener("copy", this.copy.bind(this), {
2326      signal
2327    });
2328    document.addEventListener("cut", this.cut.bind(this), {
2329      signal
2330    });
2331    document.addEventListener("paste", this.paste.bind(this), {
2332      signal
2333    });
2334  }
2335  #removeCopyPasteListeners() {
2336    this.#copyPasteAC?.abort();
2337    this.#copyPasteAC = null;
2338  }
2339  #addDragAndDropListeners() {
2340    const signal = this._signal;
2341    document.addEventListener("dragover", this.dragOver.bind(this), {
2342      signal
2343    });
2344    document.addEventListener("drop", this.drop.bind(this), {
2345      signal
2346    });
2347  }
2348  addEditListeners() {
2349    this.#addKeyboardManager();
2350    this.#addCopyPasteListeners();
2351  }
2352  removeEditListeners() {
2353    this.#removeKeyboardManager();
2354    this.#removeCopyPasteListeners();
2355  }
2356  dragOver(event) {
2357    for (const {
2358      type
2359    } of event.dataTransfer.items) {
2360      for (const editorType of this.#editorTypes) {
2361        if (editorType.isHandlingMimeForPasting(type)) {
2362          event.dataTransfer.dropEffect = "copy";
2363          event.preventDefault();
2364          return;
2365        }
2366      }
2367    }
2368  }
2369  drop(event) {
2370    for (const item of event.dataTransfer.items) {
2371      for (const editorType of this.#editorTypes) {
2372        if (editorType.isHandlingMimeForPasting(item.type)) {
2373          editorType.paste(item, this.currentLayer);
2374          event.preventDefault();
2375          return;
2376        }
2377      }
2378    }
2379  }
2380  copy(event) {
2381    event.preventDefault();
2382    this.#activeEditor?.commitOrRemove();
2383    if (!this.hasSelection) {
2384      return;
2385    }
2386    const editors = [];
2387    for (const editor of this.#selectedEditors) {
2388      const serialized = editor.serialize(true);
2389      if (serialized) {
2390        editors.push(serialized);
2391      }
2392    }
2393    if (editors.length === 0) {
2394      return;
2395    }
2396    event.clipboardData.setData("application/pdfjs", JSON.stringify(editors));
2397  }
2398  cut(event) {
2399    this.copy(event);
2400    this.delete();
2401  }
2402  async paste(event) {
2403    event.preventDefault();
2404    const {
2405      clipboardData
2406    } = event;
2407    for (const item of clipboardData.items) {
2408      for (const editorType of this.#editorTypes) {
2409        if (editorType.isHandlingMimeForPasting(item.type)) {
2410          editorType.paste(item, this.currentLayer);
2411          return;
2412        }
2413      }
2414    }
2415    let data = clipboardData.getData("application/pdfjs");
2416    if (!data) {
2417      return;
2418    }
2419    try {
2420      data = JSON.parse(data);
2421    } catch (ex) {
2422      warn(`paste: "${ex.message}".`);
2423      return;
2424    }
2425    if (!Array.isArray(data)) {
2426      return;
2427    }
2428    this.unselectAll();
2429    const layer = this.currentLayer;
2430    try {
2431      const newEditors = [];
2432      for (const editor of data) {
2433        const deserializedEditor = await layer.deserialize(editor);
2434        if (!deserializedEditor) {
2435          return;
2436        }
2437        newEditors.push(deserializedEditor);
2438      }
2439      const cmd = () => {
2440        for (const editor of newEditors) {
2441          this.#addEditorToLayer(editor);
2442        }
2443        this.#selectEditors(newEditors);
2444      };
2445      const undo = () => {
2446        for (const editor of newEditors) {
2447          editor.remove();
2448        }
2449      };
2450      this.addCommands({
2451        cmd,
2452        undo,
2453        mustExec: true
2454      });
2455    } catch (ex) {
2456      warn(`paste: "${ex.message}".`);
2457    }
2458  }
2459  keydown(event) {
2460    if (!this.isShiftKeyDown && event.key === "Shift") {
2461      this.isShiftKeyDown = true;
2462    }
2463    if (this.#mode !== AnnotationEditorType.NONE && !this.isEditorHandlingKeyboard) {
2464      AnnotationEditorUIManager._keyboardManager.exec(this, event);
2465    }
2466  }
2467  keyup(event) {
2468    if (this.isShiftKeyDown && event.key === "Shift") {
2469      this.isShiftKeyDown = false;
2470      if (this.#highlightWhenShiftUp) {
2471        this.#highlightWhenShiftUp = false;
2472        this.#onSelectEnd("main_toolbar");
2473      }
2474    }
2475  }
2476  onEditingAction({
2477    name
2478  }) {
2479    switch (name) {
2480      case "undo":
2481      case "redo":
2482      case "delete":
2483      case "selectAll":
2484        this[name]();
2485        break;
2486      case "highlightSelection":
2487        this.highlightSelection("context_menu");
2488        break;
2489    }
2490  }
2491  #dispatchUpdateStates(details) {
2492    const hasChanged = Object.entries(details).some(([key, value]) => this.#previousStates[key] !== value);
2493    if (hasChanged) {
2494      this._eventBus.dispatch("annotationeditorstateschanged", {
2495        source: this,
2496        details: Object.assign(this.#previousStates, details)
2497      });
2498      if (this.#mode === AnnotationEditorType.HIGHLIGHT && details.hasSelectedEditor === false) {
2499        this.#dispatchUpdateUI([[AnnotationEditorParamsType.HIGHLIGHT_FREE, true]]);
2500      }
2501    }
2502  }
2503  #dispatchUpdateUI(details) {
2504    this._eventBus.dispatch("annotationeditorparamschanged", {
2505      source: this,
2506      details
2507    });
2508  }
2509  setEditingState(isEditing) {
2510    if (isEditing) {
2511      this.#addFocusManager();
2512      this.#addCopyPasteListeners();
2513      this.#dispatchUpdateStates({
2514        isEditing: this.#mode !== AnnotationEditorType.NONE,
2515        isEmpty: this.#isEmpty(),
2516        hasSomethingToUndo: this.#commandManager.hasSomethingToUndo(),
2517        hasSomethingToRedo: this.#commandManager.hasSomethingToRedo(),
2518        hasSelectedEditor: false
2519      });
2520    } else {
2521      this.#removeFocusManager();
2522      this.#removeCopyPasteListeners();
2523      this.#dispatchUpdateStates({
2524        isEditing: false
2525      });
2526      this.disableUserSelect(false);
2527    }
2528  }
2529  registerEditorTypes(types) {
2530    if (this.#editorTypes) {
2531      return;
2532    }
2533    this.#editorTypes = types;
2534    for (const editorType of this.#editorTypes) {
2535      this.#dispatchUpdateUI(editorType.defaultPropertiesToUpdate);
2536    }
2537  }
2538  getId() {
2539    return this.#idManager.id;
2540  }
2541  get currentLayer() {
2542    return this.#allLayers.get(this.#currentPageIndex);
2543  }
2544  getLayer(pageIndex) {
2545    return this.#allLayers.get(pageIndex);
2546  }
2547  get currentPageIndex() {
2548    return this.#currentPageIndex;
2549  }
2550  addLayer(layer) {
2551    this.#allLayers.set(layer.pageIndex, layer);
2552    if (this.#isEnabled) {
2553      layer.enable();
2554    } else {
2555      layer.disable();
2556    }
2557  }
2558  removeLayer(layer) {
2559    this.#allLayers.delete(layer.pageIndex);
2560  }
2561  async updateMode(mode, editId = null, isFromKeyboard = false) {
2562    if (this.#mode === mode) {
2563      return;
2564    }
2565    if (this.#updateModeCapability) {
2566      await this.#updateModeCapability.promise;
2567      if (!this.#updateModeCapability) {
2568        return;
2569      }
2570    }
2571    this.#updateModeCapability = Promise.withResolvers();
2572    this.#mode = mode;
2573    if (mode === AnnotationEditorType.NONE) {
2574      this.setEditingState(false);
2575      this.#disableAll();
2576      this.#updateModeCapability.resolve();
2577      return;
2578    }
2579    this.setEditingState(true);
2580    await this.#enableAll();
2581    this.unselectAll();
2582    for (const layer of this.#allLayers.values()) {
2583      layer.updateMode(mode);
2584    }
2585    if (!editId) {
2586      if (isFromKeyboard) {
2587        this.addNewEditorFromKeyboard();
2588      }
2589      this.#updateModeCapability.resolve();
2590      return;
2591    }
2592    for (const editor of this.#allEditors.values()) {
2593      if (editor.annotationElementId === editId) {
2594        this.setSelected(editor);
2595        editor.enterInEditMode();
2596      } else {
2597        editor.unselect();
2598      }
2599    }
2600    this.#updateModeCapability.resolve();
2601  }
2602  addNewEditorFromKeyboard() {
2603    if (this.currentLayer.canCreateNewEmptyEditor()) {
2604      this.currentLayer.addNewEditor();
2605    }
2606  }
2607  updateToolbar(mode) {
2608    if (mode === this.#mode) {
2609      return;
2610    }
2611    this._eventBus.dispatch("switchannotationeditormode", {
2612      source: this,
2613      mode
2614    });
2615  }
2616  updateParams(type, value) {
2617    if (!this.#editorTypes) {
2618      return;
2619    }
2620    switch (type) {
2621      case AnnotationEditorParamsType.CREATE:
2622        this.currentLayer.addNewEditor();
2623        return;
2624      case AnnotationEditorParamsType.HIGHLIGHT_DEFAULT_COLOR:
2625        this.#mainHighlightColorPicker?.updateColor(value);
2626        break;
2627      case AnnotationEditorParamsType.HIGHLIGHT_SHOW_ALL:
2628        this._eventBus.dispatch("reporttelemetry", {
2629          source: this,
2630          details: {
2631            type: "editing",
2632            data: {
2633              type: "highlight",
2634              action: "toggle_visibility"
2635            }
2636          }
2637        });
2638        (this.#showAllStates ||= new Map()).set(type, value);
2639        this.showAllEditors("highlight", value);
2640        break;
2641    }
2642    for (const editor of this.#selectedEditors) {
2643      editor.updateParams(type, value);
2644    }
2645    for (const editorType of this.#editorTypes) {
2646      editorType.updateDefaultParams(type, value);
2647    }
2648  }
2649  showAllEditors(type, visible, updateButton = false) {
2650    for (const editor of this.#allEditors.values()) {
2651      if (editor.editorType === type) {
2652        editor.show(visible);
2653      }
2654    }
2655    const state = this.#showAllStates?.get(AnnotationEditorParamsType.HIGHLIGHT_SHOW_ALL) ?? true;
2656    if (state !== visible) {
2657      this.#dispatchUpdateUI([[AnnotationEditorParamsType.HIGHLIGHT_SHOW_ALL, visible]]);
2658    }
2659  }
2660  enableWaiting(mustWait = false) {
2661    if (this.#isWaiting === mustWait) {
2662      return;
2663    }
2664    this.#isWaiting = mustWait;
2665    for (const layer of this.#allLayers.values()) {
2666      if (mustWait) {
2667        layer.disableClick();
2668      } else {
2669        layer.enableClick();
2670      }
2671      layer.div.classList.toggle("waiting", mustWait);
2672    }
2673  }
2674  async #enableAll() {
2675    if (!this.#isEnabled) {
2676      this.#isEnabled = true;
2677      const promises = [];
2678      for (const layer of this.#allLayers.values()) {
2679        promises.push(layer.enable());
2680      }
2681      await Promise.all(promises);
2682      for (const editor of this.#allEditors.values()) {
2683        editor.enable();
2684      }
2685    }
2686  }
2687  #disableAll() {
2688    this.unselectAll();
2689    if (this.#isEnabled) {
2690      this.#isEnabled = false;
2691      for (const layer of this.#allLayers.values()) {
2692        layer.disable();
2693      }
2694      for (const editor of this.#allEditors.values()) {
2695        editor.disable();
2696      }
2697    }
2698  }
2699  getEditors(pageIndex) {
2700    const editors = [];
2701    for (const editor of this.#allEditors.values()) {
2702      if (editor.pageIndex === pageIndex) {
2703        editors.push(editor);
2704      }
2705    }
2706    return editors;
2707  }
2708  getEditor(id) {
2709    return this.#allEditors.get(id);
2710  }
2711  addEditor(editor) {
2712    this.#allEditors.set(editor.id, editor);
2713  }
2714  removeEditor(editor) {
2715    if (editor.div.contains(document.activeElement)) {
2716      if (this.#focusMainContainerTimeoutId) {
2717        clearTimeout(this.#focusMainContainerTimeoutId);
2718      }
2719      this.#focusMainContainerTimeoutId = setTimeout(() => {
2720        this.focusMainContainer();
2721        this.#focusMainContainerTimeoutId = null;
2722      }, 0);
2723    }
2724    this.#allEditors.delete(editor.id);
2725    this.unselect(editor);
2726    if (!editor.annotationElementId || !this.#deletedAnnotationsElementIds.has(editor.annotationElementId)) {
2727      this.#annotationStorage?.remove(editor.id);
2728    }
2729  }
2730  addDeletedAnnotationElement(editor) {
2731    this.#deletedAnnotationsElementIds.add(editor.annotationElementId);
2732    this.addChangedExistingAnnotation(editor);
2733    editor.deleted = true;
2734  }
2735  isDeletedAnnotationElement(annotationElementId) {
2736    return this.#deletedAnnotationsElementIds.has(annotationElementId);
2737  }
2738  removeDeletedAnnotationElement(editor) {
2739    this.#deletedAnnotationsElementIds.delete(editor.annotationElementId);
2740    this.removeChangedExistingAnnotation(editor);
2741    editor.deleted = false;
2742  }
2743  #addEditorToLayer(editor) {
2744    const layer = this.#allLayers.get(editor.pageIndex);
2745    if (layer) {
2746      layer.addOrRebuild(editor);
2747    } else {
2748      this.addEditor(editor);
2749      this.addToAnnotationStorage(editor);
2750    }
2751  }
2752  setActiveEditor(editor) {
2753    if (this.#activeEditor === editor) {
2754      return;
2755    }
2756    this.#activeEditor = editor;
2757    if (editor) {
2758      this.#dispatchUpdateUI(editor.propertiesToUpdate);
2759    }
2760  }
2761  get #lastSelectedEditor() {
2762    let ed = null;
2763    for (ed of this.#selectedEditors) {}
2764    return ed;
2765  }
2766  updateUI(editor) {
2767    if (this.#lastSelectedEditor === editor) {
2768      this.#dispatchUpdateUI(editor.propertiesToUpdate);
2769    }
2770  }
2771  toggleSelected(editor) {
2772    if (this.#selectedEditors.has(editor)) {
2773      this.#selectedEditors.delete(editor);
2774      editor.unselect();
2775      this.#dispatchUpdateStates({
2776        hasSelectedEditor: this.hasSelection
2777      });
2778      return;
2779    }
2780    this.#selectedEditors.add(editor);
2781    editor.select();
2782    this.#dispatchUpdateUI(editor.propertiesToUpdate);
2783    this.#dispatchUpdateStates({
2784      hasSelectedEditor: true
2785    });
2786  }
2787  setSelected(editor) {
2788    for (const ed of this.#selectedEditors) {
2789      if (ed !== editor) {
2790        ed.unselect();
2791      }
2792    }
2793    this.#selectedEditors.clear();
2794    this.#selectedEditors.add(editor);
2795    editor.select();
2796    this.#dispatchUpdateUI(editor.propertiesToUpdate);
2797    this.#dispatchUpdateStates({
2798      hasSelectedEditor: true
2799    });
2800  }
2801  isSelected(editor) {
2802    return this.#selectedEditors.has(editor);
2803  }
2804  get firstSelectedEditor() {
2805    return this.#selectedEditors.values().next().value;
2806  }
2807  unselect(editor) {
2808    editor.unselect();
2809    this.#selectedEditors.delete(editor);
2810    this.#dispatchUpdateStates({
2811      hasSelectedEditor: this.hasSelection
2812    });
2813  }
2814  get hasSelection() {
2815    return this.#selectedEditors.size !== 0;
2816  }
2817  get isEnterHandled() {
2818    return this.#selectedEditors.size === 1 && this.firstSelectedEditor.isEnterHandled;
2819  }
2820  undo() {
2821    this.#commandManager.undo();
2822    this.#dispatchUpdateStates({
2823      hasSomethingToUndo: this.#commandManager.hasSomethingToUndo(),
2824      hasSomethingToRedo: true,
2825      isEmpty: this.#isEmpty()
2826    });
2827  }
2828  redo() {
2829    this.#commandManager.redo();
2830    this.#dispatchUpdateStates({
2831      hasSomethingToUndo: true,
2832      hasSomethingToRedo: this.#commandManager.hasSomethingToRedo(),
2833      isEmpty: this.#isEmpty()
2834    });
2835  }
2836  addCommands(params) {
2837    this.#commandManager.add(params);
2838    this.#dispatchUpdateStates({
2839      hasSomethingToUndo: true,
2840      hasSomethingToRedo: false,
2841      isEmpty: this.#isEmpty()
2842    });
2843  }
2844  #isEmpty() {
2845    if (this.#allEditors.size === 0) {
2846      return true;
2847    }
2848    if (this.#allEditors.size === 1) {
2849      for (const editor of this.#allEditors.values()) {
2850        return editor.isEmpty();
2851      }
2852    }
2853    return false;