https://orijins.ai/assets/pdf.worker-CPbhI6B3.mjs

25
26 */
27
28;// ./src/shared/util.js
29const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
30const BBOX_INIT = [Infinity, Infinity, -Infinity, -Infinity];
31const F32_BBOX_INIT = new Float32Array(BBOX_INIT);
32const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
33const LINE_FACTOR = 1.35;
34const LINE_DESCENT_FACTOR = 0.35;
35const BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
36const SVG_NS = "http://www.w3.org/2000/svg";
37const RenderingIntentFlag = {
38  ANY: 0x01,
39  DISPLAY: 0x02,
40  PRINT: 0x04,
41  SAVE: 0x08,
42  ANNOTATIONS_FORMS: 0x10,
43  ANNOTATIONS_STORAGE: 0x20,
44  ANNOTATIONS_DISABLE: 0x40,
45  IS_EDITING: 0x80,
46  OPLIST: 0x100
47};
48const AnnotationMode = (/* unused pure expression or super */ null && ({
49  DISABLE: 0,
50  ENABLE: 1,
51  ENABLE_FORMS: 2,
52  ENABLE_STORAGE: 3
53}));
54const AnnotationPrefix = "pdfjs_internal_id_";
55const AnnotationEditorPrefix = "pdfjs_internal_editor_";
56const AnnotationEditorType = {
57  DISABLE: -1,
58  NONE: 0,
59  FREETEXT: 3,
60  HIGHLIGHT: 9,
61  STAMP: 13,
62  INK: 15,
63  POPUP: 16,
64  SIGNATURE: 101,
65  COMMENT: 102
66};
67const AnnotationEditorParamsType = (/* unused pure expression or super */ null && ({
68  RESIZE: 1,
69  CREATE: 2,
70  FREETEXT_SIZE: 11,
71  FREETEXT_COLOR: 12,
72  FREETEXT_OPACITY: 13,
73  INK_COLOR: 21,
74  INK_THICKNESS: 22,
75  INK_OPACITY: 23,
76  INK_COLOR_AND_OPACITY: 24,
77  HIGHLIGHT_COLOR: 31,
78  HIGHLIGHT_THICKNESS: 32,
79  HIGHLIGHT_FREE: 33,
80  HIGHLIGHT_SHOW_ALL: 34,
81  DRAW_STEP: 41
82}));
83const PermissionFlag = {
84  PRINT: 0x04,
85  MODIFY_CONTENTS: 0x08,
86  COPY: 0x10,
87  MODIFY_ANNOTATIONS: 0x20,
88  FILL_INTERACTIVE_FORMS: 0x100,
89  COPY_FOR_ACCESSIBILITY: 0x200,
90  ASSEMBLE: 0x400,
91  PRINT_HIGH_QUALITY: 0x800
92};
93const MeshFigureType = {
94  TRIANGLES: 1,
95  LATTICE: 2,
96  PATCH: 3
97};
98const TextRenderingMode = {
99  FILL: 0,
100  STROKE: 1,
101  FILL_STROKE: 2,
102  INVISIBLE: 3,
103  FILL_ADD_TO_PATH: 4,
104  STROKE_ADD_TO_PATH: 5,
105  FILL_STROKE_ADD_TO_PATH: 6,
106  ADD_TO_PATH: 7,
107  FILL_STROKE_MASK: 3,
108  ADD_TO_PATH_FLAG: 4
109};
110const ImageKind = {
111  GRAYSCALE_1BPP: 1,
112  RGB_24BPP: 2,
113  RGBA_32BPP: 3
114};
115const AnnotationType = {
116  TEXT: 1,
117  LINK: 2,
118  FREETEXT: 3,
119  LINE: 4,
120  SQUARE: 5,
121  CIRCLE: 6,
122  POLYGON: 7,
123  POLYLINE: 8,
124  HIGHLIGHT: 9,
125  UNDERLINE: 10,
126  SQUIGGLY: 11,
127  STRIKEOUT: 12,
128  STAMP: 13,
129  CARET: 14,
130  INK: 15,
131  POPUP: 16,
132  FILEATTACHMENT: 17,
133  SOUND: 18,
134  MOVIE: 19,
135  WIDGET: 20,
136  SCREEN: 21,
137  PRINTERMARK: 22,
138  TRAPNET: 23,
139  WATERMARK: 24,
140  THREED: 25,
141  REDACT: 26,
142  RICHMEDIA: 27
143};
144const AnnotationReplyType = {
145  GROUP: "Group",
146  REPLY: "R"
147};
148const AnnotationRenditionOperation = {
149  PLAY_OR_RESUME: 0,
150  STOP: 1,
151  PAUSE: 2,
152  RESUME: 3,
153  PLAY: 4
154};
155const AnnotationFlag = {
156  INVISIBLE: 0x01,
157  HIDDEN: 0x02,
158  PRINT: 0x04,
159  NOZOOM: 0x08,
160  NOROTATE: 0x10,
161  NOVIEW: 0x20,
162  READONLY: 0x40,
163  LOCKED: 0x80,
164  TOGGLENOVIEW: 0x100,
165  LOCKEDCONTENTS: 0x200
166};
167const AnnotationFieldFlag = {
168  READONLY: 0x0000001,
169  REQUIRED: 0x0000002,
170  NOEXPORT: 0x0000004,
171  MULTILINE: 0x0001000,
172  PASSWORD: 0x0002000,
173  NOTOGGLETOOFF: 0x0004000,
174  RADIO: 0x0008000,
175  PUSHBUTTON: 0x0010000,
176  COMBO: 0x0020000,
177  EDIT: 0x0040000,
178  SORT: 0x0080000,
179  FILESELECT: 0x0100000,
180  MULTISELECT: 0x0200000,
181  DONOTSPELLCHECK: 0x0400000,
182  DONOTSCROLL: 0x0800000,
183  COMB: 0x1000000,
184  RICHTEXT: 0x2000000,
185  RADIOSINUNISON: 0x2000000,
186  COMMITONSELCHANGE: 0x4000000
187};
188const AnnotationBorderStyleType = {
189  SOLID: 1,
190  DASHED: 2,
191  BEVELED: 3,
192  INSET: 4,
193  UNDERLINE: 5
194};
195const AnnotationActionEventType = {
196  E: "Mouse Enter",
197  X: "Mouse Exit",
198  D: "Mouse Down",
199  U: "Mouse Up",
200  Fo: "Focus",
201  Bl: "Blur",
202  PO: "PageOpen",
203  PC: "PageClose",
204  PV: "PageVisible",
205  PI: "PageInvisible",
206  K: "Keystroke",
207  F: "Format",
208  V: "Validate",
209  C: "Calculate"
210};
211const DocumentActionEventType = {
212  WC: "WillClose",
213  WS: "WillSave",
214  DS: "DidSave",
215  WP: "WillPrint",
216  DP: "DidPrint"
217};
218const PageActionEventType = {
219  O: "PageOpen",
220  C: "PageClose"
221};
222const VerbosityLevel = {
223  ERRORS: 0,
224  WARNINGS: 1,
225  INFOS: 5
226};
227const OPS = {
228  dependency: 1,
229  setLineWidth: 2,
230  setLineCap: 3,
231  setLineJoin: 4,
232  setMiterLimit: 5,
233  setDash: 6,
234  setRenderingIntent: 7,
235  setFlatness: 8,
236  setGState: 9,
237  save: 10,
238  restore: 11,
239  transform: 12,
240  moveTo: 13,
241  lineTo: 14,
242  curveTo: 15,
243  curveTo2: 16,
244  curveTo3: 17,
245  closePath: 18,
246  rectangle: 19,
247  stroke: 20,
248  closeStroke: 21,
249  fill: 22,
250  eoFill: 23,
251  fillStroke: 24,
252  eoFillStroke: 25,
253  closeFillStroke: 26,
254  closeEOFillStroke: 27,
255  endPath: 28,
256  clip: 29,
257  eoClip: 30,
258  beginText: 31,
259  endText: 32,
260  setCharSpacing: 33,
261  setWordSpacing: 34,
262  setHScale: 35,
263  setLeading: 36,
264  setFont: 37,
265  setTextRenderingMode: 38,
266  setTextRise: 39,
267  moveText: 40,
268  setLeadingMoveText: 41,
269  setTextMatrix: 42,
270  nextLine: 43,
271  showText: 44,
272  showSpacedText: 45,
273  nextLineShowText: 46,
274  nextLineSetSpacingShowText: 47,
275  setCharWidth: 48,
276  setCharWidthAndBounds: 49,
277  setStrokeColorSpace: 50,
278  setFillColorSpace: 51,
279  setStrokeColor: 52,
280  setStrokeColorN: 53,
281  setFillColor: 54,
282  setFillColorN: 55,
283  setStrokeGray: 56,
284  setFillGray: 57,
285  setStrokeRGBColor: 58,
286  setFillRGBColor: 59,
287  setStrokeCMYKColor: 60,
288  setFillCMYKColor: 61,
289  shadingFill: 62,
290  beginInlineImage: 63,
291  beginImageData: 64,
292  endInlineImage: 65,
293  paintXObject: 66,
294  markPoint: 67,
295  markPointProps: 68,
296  beginMarkedContent: 69,
297  beginMarkedContentProps: 70,
298  endMarkedContent: 71,
299  beginCompat: 72,
300  endCompat: 73,
301  paintFormXObjectBegin: 74,
302  paintFormXObjectEnd: 75,
303  beginGroup: 76,
304  endGroup: 77,
305  beginAnnotation: 80,
306  endAnnotation: 81,
307  paintImageMaskXObject: 83,
308  paintImageMaskXObjectGroup: 84,
309  paintImageXObject: 85,
310  paintInlineImageXObject: 86,
311  paintInlineImageXObjectGroup: 87,
312  paintImageXObjectRepeat: 88,
313  paintImageMaskXObjectRepeat: 89,
314  paintSolidColorImageMask: 90,
315  constructPath: 91,
316  setStrokeTransparent: 92,
317  setFillTransparent: 93,
318  rawFillPath: 94
319};
320const DrawOPS = {
321  moveTo: 0,
322  lineTo: 1,
323  curveTo: 2,
324  quadraticCurveTo: 3,
325  closePath: 4
326};
327const PasswordResponses = {
328  NEED_PASSWORD: 1,
329  INCORRECT_PASSWORD: 2
330};
331let verbosity = VerbosityLevel.WARNINGS;
332function setVerbosityLevel(level) {
333  if (Number.isInteger(level)) {
334    verbosity = level;
335  }
336}
337function getVerbosityLevel() {
338  return verbosity;
339}
340function info(msg) {
341  if (verbosity >= VerbosityLevel.INFOS) {
342    console.info(`Info: ${msg}`);
343  }
344}
345function warn(msg) {
346  if (verbosity >= VerbosityLevel.WARNINGS) {
347    console.warn(`Warning: ${msg}`);
348  }
349}
350function unreachable(msg) {
351  throw new Error(msg);
352}
353function assert(cond, msg) {
354  if (!cond) {
355    unreachable(msg);
356  }
357}
358function _isValidProtocol(url) {
359  switch (url?.protocol) {
360    case "http:":
361    case "https:":
362    case "ftp:":
363    case "mailto:":
364    case "tel:":
365      return true;
366    default:
367      return false;
368  }
369}
370function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
371  if (!url) {
372    return null;
373  }
374  if (options && typeof url === "string") {
375    if (options.addDefaultProtocol && url.startsWith("www.")) {
376      const dots = url.match(/\./g);
377      if (dots?.length >= 2) {
378        url = `http://${url}`;
379      }
380    }
381    if (options.tryConvertEncoding) {
382      try {
383        url = stringToUTF8String(url);
384      } catch {}
385    }
386  }
387  const absoluteUrl = baseUrl ? URL.parse(url, baseUrl) : URL.parse(url);
388  return _isValidProtocol(absoluteUrl) ? absoluteUrl : null;
389}
390function updateUrlHash(url, hash, allowRel = false) {
391  const res = URL.parse(url);
392  if (res) {
393    res.hash = hash;
394    return res.href;
395  }
396  if (allowRel && createValidAbsoluteUrl(url, "http://example.com")) {
397    return url.split("#", 1)[0] + `${hash ? `#${hash}` : ""}`;
398  }
399  return "";
400}
401function stripPath(str) {
402  return str.substring(str.lastIndexOf("/") + 1);
403}
404function shadow(obj, prop, value, nonSerializable = false) {
405  Object.defineProperty(obj, prop, {
406    value,
407    enumerable: !nonSerializable,
408    configurable: true,
409    writable: false
410  });
411  return value;
412}
413const BaseException = function BaseExceptionClosure() {
414  function BaseException(message, name) {
415    this.message = message;
416    this.name = name;
417  }
418  BaseException.prototype = new Error();
419  BaseException.constructor = BaseException;
420  return BaseException;
421}();
422class PasswordException extends BaseException {
423  constructor(msg, code) {
424    super(msg, "PasswordException");
425    this.code = code;
426  }
427}
428class UnknownErrorException extends BaseException {
429  constructor(msg, details) {
430    super(msg, "UnknownErrorException");
431    this.details = details;
432  }
433}
434class InvalidPDFException extends BaseException {
435  constructor(msg) {
436    super(msg, "InvalidPDFException");
437  }
438}
439class ResponseException extends BaseException {
440  constructor(msg, status, missing) {
441    super(msg, "ResponseException");
442    this.status = status;
443    this.missing = missing;
444  }
445}
446class FormatError extends BaseException {
447  constructor(msg) {
448    super(msg, "FormatError");
449  }
450}
451class AbortException extends BaseException {
452  constructor(msg) {
453    super(msg, "AbortException");
454  }
455}
456function bytesToString(bytes) {
457  if (typeof bytes !== "object" || bytes?.length === undefined) {
458    unreachable("Invalid argument for bytesToString");
459  }
460  const length = bytes.length;
461  const MAX_ARGUMENT_COUNT = 8192;
462  if (length < MAX_ARGUMENT_COUNT) {
463    return String.fromCharCode.apply(null, bytes);
464  }
465  const strBuf = [];
466  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
467    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
468    const chunk = bytes.subarray(i, chunkEnd);
469    strBuf.push(String.fromCharCode.apply(null, chunk));
470  }
471  return strBuf.join("");
472}
473function stringToBytes(str) {
474  if (typeof str !== "string") {
475    unreachable("Invalid argument for stringToBytes");
476  }
477  const length = str.length;
478  const bytes = new Uint8Array(length);
479  for (let i = 0; i < length; ++i) {
480    bytes[i] = str.charCodeAt(i) & 0xff;
481  }
482  return bytes;
483}

484function objectSize(obj) {
485  return Object.keys(obj).length;
486}
487class FeatureTest {
488  static get isLittleEndian() {
489    const buffer8 = new Uint8Array(4);
490    buffer8[0] = 1;
491    const view32 = new Uint32Array(buffer8.buffer, 0, 1);
492    return shadow(this, "isLittleEndian", view32[0] === 1);
493  }
494  static get isOffscreenCanvasSupported() {
495    return shadow(this, "isOffscreenCanvasSupported", typeof OffscreenCanvas !== "undefined");
496  }
497  static get isImageDecoderSupported() {
498    return shadow(this, "isImageDecoderSupported", typeof ImageDecoder !== "undefined");
499  }
500  static get isFloat16ArraySupported() {
501    return shadow(this, "isFloat16ArraySupported", typeof Float16Array !== "undefined");
502  }
503  static get isSanitizerSupported() {
504    return shadow(this, "isSanitizerSupported", typeof Sanitizer !== "undefined");
505  }
506  static get platform() {
507    const {
508      platform,
509      userAgent
510    } = navigator;
511    return shadow(this, "platform", {
512      isAndroid: userAgent.includes("Android"),
513      isLinux: platform.includes("Linux"),
514      isMac: platform.includes("Mac"),
515      isWindows: platform.includes("Win"),
516      isFirefox: userAgent.includes("Firefox")
517    });
518  }
519  static get isCanvasFilterSupported() {

520    let ctx;
521    if (this.isOffscreenCanvasSupported) {
522      ctx = new OffscreenCanvas(1, 1).getContext("2d");
523    }
524    return shadow(this, "isCanvasFilterSupported", ctx?.filter !== undefined);
525  }
526  static get isAlphaColorInputSupported() {
527    return shadow(this, "isAlphaColorInputSupported", false);
528  }
529  static get isBackdropFilterSupported() {
530    return shadow(this, "isBackdropFilterSupported", typeof CSS !== "undefined" && CSS.supports("backdrop-filter", "blur(1px)"));
531  }
532}
533class Util {
534  static get hexNums() {
535    return shadow(this, "hexNums", Array.from(Array(256).keys(), n => n.toString(16).padStart(2, "0")));
536  }
537  static makeHexColor(r, g, b) {
538    return `#${this.hexNums[r]}${this.hexNums[g]}${this.hexNums[b]}`;
539  }
540  static transform(m1, m2) {
541    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]];
542  }
543  static multiplyByDOMMatrix(m, md) {
544    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]];
545  }
546  static applyTransform(p, m, pos = 0) {
547    const p0 = p[pos];
548    const p1 = p[pos + 1];
549    p[pos] = p0 * m[0] + p1 * m[2] + m[4];
550    p[pos + 1] = p0 * m[1] + p1 * m[3] + m[5];
551  }
552  static applyTransformToBezier(p, transform, pos = 0) {
553    const m0 = transform[0];
554    const m1 = transform[1];
555    const m2 = transform[2];
556    const m3 = transform[3];
557    const m4 = transform[4];
558    const m5 = transform[5];
559    for (let i = 0; i < 6; i += 2) {
560      const pI = p[pos + i];
561      const pI1 = p[pos + i + 1];
562      p[pos + i] = pI * m0 + pI1 * m2 + m4;
563      p[pos + i + 1] = pI * m1 + pI1 * m3 + m5;
564    }
565  }
566  static applyInverseTransform(p, m) {
567    const p0 = p[0];
568    const p1 = p[1];
569    const d = m[0] * m[3] - m[1] * m[2];
570    p[0] = (p0 * m[3] - p1 * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
571    p[1] = (-p0 * m[1] + p1 * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
572  }
573  static axialAlignedBoundingBox(rect, transform, output) {
574    const m0 = transform[0];
575    const m1 = transform[1];
576    const m2 = transform[2];
577    const m3 = transform[3];
578    const m4 = transform[4];
579    const m5 = transform[5];
580    const r0 = rect[0];
581    const r1 = rect[1];
582    const r2 = rect[2];
583    const r3 = rect[3];
584    let a0 = m0 * r0 + m4;
585    let a2 = a0;
586    let a1 = m0 * r2 + m4;
587    let a3 = a1;
588    let b0 = m3 * r1 + m5;
589    let b2 = b0;
590    let b1 = m3 * r3 + m5;
591    let b3 = b1;
592    if (m1 !== 0 || m2 !== 0) {
593      const m1r0 = m1 * r0;
594      const m1r2 = m1 * r2;
595      const m2r1 = m2 * r1;
596      const m2r3 = m2 * r3;
597      a0 += m2r1;
598      a3 += m2r1;
599      a1 += m2r3;
600      a2 += m2r3;
601      b0 += m1r0;
602      b3 += m1r0;
603      b1 += m1r2;
604      b2 += m1r2;
605    }
606    output[0] = Math.min(output[0], a0, a1, a2, a3);
607    output[1] = Math.min(output[1], b0, b1, b2, b3);
608    output[2] = Math.max(output[2], a0, a1, a2, a3);
609    output[3] = Math.max(output[3], b0, b1, b2, b3);
610  }
611  static inverseTransform(m) {
612    const d = m[0] * m[3] - m[1] * m[2];
613    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];
614  }
615  static singularValueDecompose2dScale(matrix, output) {
616    const m0 = matrix[0];
617    const m1 = matrix[1];
618    const m2 = matrix[2];
619    const m3 = matrix[3];
620    const a = m0 ** 2 + m1 ** 2;
621    const b = m0 * m2 + m1 * m3;
622    const c = m2 ** 2 + m3 ** 2;
623    const first = (a + c) / 2;
624    const second = Math.sqrt(first ** 2 - (a * c - b ** 2));
625    output[0] = Math.sqrt(first + second || 1);
626    output[1] = Math.sqrt(first - second || 1);
627  }
628  static normalizeRect(rect) {
629    const r = rect.slice(0);
630    if (rect[0] > rect[2]) {
631      r[0] = rect[2];
632      r[2] = rect[0];
633    }
634    if (rect[1] > rect[3]) {
635      r[1] = rect[3];
636      r[3] = rect[1];
637    }
638    return r;
639  }
640  static intersect(rect1, rect2) {
641    const xLow = Math.max(Math.min(rect1[0], rect1[2]), Math.min(rect2[0], rect2[2]));
642    const xHigh = Math.min(Math.max(rect1[0], rect1[2]), Math.max(rect2[0], rect2[2]));
643    if (xLow > xHigh) {
644      return null;
645    }
646    const yLow = Math.max(Math.min(rect1[1], rect1[3]), Math.min(rect2[1], rect2[3]));
647    const yHigh = Math.min(Math.max(rect1[1], rect1[3]), Math.max(rect2[1], rect2[3]));
648    if (yLow > yHigh) {
649      return null;
650    }
651    return [xLow, yLow, xHigh, yHigh];
652  }
653  static pointBoundingBox(x, y, minMax) {
654    minMax[0] = Math.min(minMax[0], x);
655    minMax[1] = Math.min(minMax[1], y);
656    minMax[2] = Math.max(minMax[2], x);
657    minMax[3] = Math.max(minMax[3], y);
658  }
659  static rectBoundingBox(x0, y0, x1, y1, minMax) {
660    minMax[0] = Math.min(minMax[0], x0, x1);
661    minMax[1] = Math.min(minMax[1], y0, y1);
662    minMax[2] = Math.max(minMax[2], x0, x1);
663    minMax[3] = Math.max(minMax[3], y0, y1);
664  }
665  static #getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, t, minMax) {
666    if (t <= 0 || t >= 1) {
667      return;
668    }
669    const mt = 1 - t;
670    const tt = t * t;
671    const ttt = tt * t;
672    const x = mt * (mt * (mt * x0 + 3 * t * x1) + 3 * tt * x2) + ttt * x3;
673    const y = mt * (mt * (mt * y0 + 3 * t * y1) + 3 * tt * y2) + ttt * y3;
674    minMax[0] = Math.min(minMax[0], x);
675    minMax[1] = Math.min(minMax[1], y);
676    minMax[2] = Math.max(minMax[2], x);
677    minMax[3] = Math.max(minMax[3], y);
678  }
679  static #getExtremum(x0, x1, x2, x3, y0, y1, y2, y3, a, b, c, minMax) {
680    if (Math.abs(a) < 1e-12) {
681      if (Math.abs(b) >= 1e-12) {
682        this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, -c / b, minMax);
683      }
684      return;
685    }
686    const delta = b ** 2 - 4 * c * a;
687    if (delta < 0) {
688      return;
689    }
690    const sqrtDelta = Math.sqrt(delta);
691    const a2 = 2 * a;
692    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b + sqrtDelta) / a2, minMax);
693    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b - sqrtDelta) / a2, minMax);
694  }
695  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3, minMax) {
696    minMax[0] = Math.min(minMax[0], x0, x3);
697    minMax[1] = Math.min(minMax[1], y0, y3);
698    minMax[2] = Math.max(minMax[2], x0, x3);
699    minMax[3] = Math.max(minMax[3], y0, y3);
700    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);
701    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);
702  }
703}
704function stringToUTF8String(str) {
705  return decodeURIComponent(escape(str));
706}
707function utf8StringToString(str) {
708  return unescape(encodeURIComponent(str));
709}
710function isArrayEqual(arr1, arr2) {
711  if (arr1.length !== arr2.length) {
712    return false;
713  }
714  for (let i = 0, ii = arr1.length; i < ii; i++) {
715    if (arr1[i] !== arr2[i]) {
716      return false;
717    }
718  }
719  return true;
720}
721let NormalizeRegex = null;
722let NormalizationMap = null;
723function normalizeUnicode(str) {
724  if (!NormalizeRegex) {
725    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;
726    NormalizationMap = new Map([["ſt", "ſt"]]);
727  }
728  return str.replaceAll(NormalizeRegex, (_, p1, p2) => p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2));
729}
730function getUuid() {
731  if (typeof crypto.randomUUID === "function") {
732    return crypto.randomUUID();
733  }
734  const buf = new Uint8Array(32);
735  crypto.getRandomValues(buf);
736  return bytesToString(buf);
737}
738function _isValidExplicitDest(validRef, validName, dest) {
739  if (!Array.isArray(dest) || dest.length < 2) {
740    return false;
741  }
742  const [page, zoom, ...args] = dest;
743  if (!validRef(page) && !Number.isInteger(page)) {
744    return false;
745  }
746  if (!validName(zoom)) {
747    return false;
748  }
749  const argsLen = args.length;
750  let allowNull = true;
751  switch (zoom.name) {
752    case "XYZ":
753      if (argsLen < 2 || argsLen > 3) {
754        return false;
755      }
756      break;
757    case "Fit":
758    case "FitB":
759      return argsLen === 0;
760    case "FitH":
761    case "FitBH":
762    case "FitV":
763    case "FitBV":
764      if (argsLen > 1) {
765        return false;
766      }
767      break;
768    case "FitR":
769      if (argsLen !== 4) {
770        return false;
771      }
772      allowNull = false;
773      break;
774    default:
775      return false;
776  }
777  for (const arg of args) {
778    if (typeof arg === "number" || allowNull && arg === null) {
779      continue;
780    }
781    return false;
782  }
783  return true;
784}
785const makeArr = () => [];
786const makeMap = () => new Map();
787const makeObj = () => Object.create(null);
788
789;// ./src/core/primitives.js
790
791const CIRCULAR_REF = Symbol("CIRCULAR_REF");
792const EOF = Symbol("EOF");
793let CmdCache = Object.create(null);
794let NameCache = Object.create(null);
795let RefCache = Object.create(null);
796function clearPrimitiveCaches() {
797  CmdCache = Object.create(null);
798  NameCache = Object.create(null);
799  RefCache = Object.create(null);
800}
801class Name {
802  constructor(name) {
803    this.name = name;
804  }
805  static get(name) {
806    return NameCache[name] ||= new Name(name);
807  }
808}
809class Cmd {
810  constructor(cmd) {
811    this.cmd = cmd;
812  }
813  static get(cmd) {
814    return CmdCache[cmd] ||= new Cmd(cmd);
815  }
816}
817const nonSerializable = function nonSerializableClosure() {
818  return nonSerializable;
819};
820class Dict {
821  __nonSerializable__ = nonSerializable;
822  #map = new Map();
823  objId = null;
824  suppressEncryption = false;
825  xref;
826  constructor(xref = null) {
827    this.xref = xref;
828  }
829  assignXref(newXref) {
830    this.xref = newXref;
831  }
832  get size() {
833    return this.#map.size;
834  }
835  #getValue(isAsync, key1, key2, key3) {
836    let value = this.#map.get(key1);
837    if (value === undefined && key2 !== undefined) {
838      value = this.#map.get(key2);
839      if (value === undefined && key3 !== undefined) {
840        value = this.#map.get(key3);
841      }
842    }
843    if (value instanceof Ref && this.xref) {
844      return isAsync ? this.xref.fetchAsync(value, this.suppressEncryption) : this.xref.fetch(value, this.suppressEncryption);
845    }
846    return value;
847  }
848  get(key1, key2, key3) {
849    return this.#getValue(false, key1, key2, key3);
850  }
851  async getAsync(key1, key2, key3) {
852    return this.#getValue(true, key1, key2, key3);
853  }
854  getArray(key1, key2, key3) {
855    let value = this.#getValue(false, key1, key2, key3);
856    if (Array.isArray(value)) {
857      value = value.slice();
858      for (let i = 0, ii = value.length; i < ii; i++) {
859        if (value[i] instanceof Ref && this.xref) {
860          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
861        }
862      }
863    }
864    return value;
865  }
866  getRaw(key) {
867    return this.#map.get(key);
868  }
869  getKeys() {
870    return this.#map.keys();
871  }
872  getRawValues() {
873    return this.#map.values();
874  }
875  getRawEntries() {
876    return this.#map.entries();
877  }
878  set(key, value) {
879    this.#map.set(key, value);
880  }
881  setIfNotExists(key, value) {
882    if (!this.has(key)) {
883      this.set(key, value);
884    }
885  }
886  setIfNumber(key, value) {
887    if (typeof value === "number") {
888      this.set(key, value);
889    }
890  }
891  setIfArray(key, value) {
892    if (Array.isArray(value) || ArrayBuffer.isView(value)) {
893      this.set(key, value);
894    }
895  }
896  setIfDefined(key, value) {
897    if (value !== undefined && value !== null) {
898      this.set(key, value);
899    }
900  }
901  setIfName(key, value) {
902    if (typeof value === "string") {
903      this.set(key, Name.get(value));
904    } else if (value instanceof Name) {
905      this.set(key, value);
906    }
907  }
908  setIfDict(key, value) {
909    if (value instanceof Dict) {
910      this.set(key, value);
911    }
912  }
913  has(key) {
914    return this.#map.has(key);
915  }
916  *[Symbol.iterator]() {
917    for (const [key, value] of this.#map) {
918      yield [key, value instanceof Ref && this.xref ? this.xref.fetch(value, this.suppressEncryption) : value];
919    }
920  }
921  static get empty() {
922    const emptyDict = new Dict(null);
923    emptyDict.set = (key, value) => {
924      unreachable("Should not call `set` on the empty dictionary.");
925    };
926    return shadow(this, "empty", emptyDict);
927  }
928  static merge({
929    xref,
930    dictArray,
931    mergeSubDicts = false
932  }) {
933    const mergedDict = new Dict(xref),
934      properties = new Map();
935    for (const dict of dictArray) {
936      if (!(dict instanceof Dict)) {
937        continue;
938      }
939      for (const [key, value] of dict.getRawEntries()) {
940        const property = properties.getOrInsertComputed(key, makeArr);
941        if (property.length && !(mergeSubDicts && value instanceof Dict)) {
942          continue;
943        }
944        property.push(value);
945      }
946    }
947    for (const [name, values] of properties) {
948      if (values.length === 1 || !(values[0] instanceof Dict)) {
949        mergedDict.set(name, values[0]);
950        continue;
951      }
952      const subDict = new Dict(xref);
953      for (const dict of values) {
954        for (const [key, value] of dict.getRawEntries()) {
955          subDict.setIfNotExists(key, value);
956        }
957      }
958      if (subDict.size > 0) {
959        mergedDict.set(name, subDict);
960      }
961    }
962    properties.clear();
963    return mergedDict.size > 0 ? mergedDict : Dict.empty;
964  }
965  clone() {
966    const dict = new Dict(this.xref);
967    for (const [key, value] of this.#map) {
968      dict.set(key, value);
969    }
970    return dict;
971  }
972  delete(key) {
973    this.#map.delete(key);
974  }
975}
976class Ref {
977  constructor(num, gen) {
978    this.num = num;
979    this.gen = gen;
980  }
981  toString() {
982    if (this.gen === 0) {
983      return `${this.num}R`;
984    }
985    return `${this.num}R${this.gen}`;
986  }
987  static fromString(str) {
988    const ref = RefCache[str];
989    if (ref) {
990      return ref;
991    }
992    const m = /^(\d+)R(\d*)$/.exec(str);
993    if (!m || m[1] === "0") {
994      return null;
995    }
996    return RefCache[str] = new Ref(parseInt(m[1], 10), !m[2] ? 0 : parseInt(m[2], 10));
997  }
998  static get(num, gen) {

1216      try {
1217        const decoder = new TextDecoder(encoding, {
1218          fatal: true
1219        });
1220        const buffer = stringToBytes(str);
1221        const decoded = decoder.decode(buffer);
1222        if (keepEscapeSequence || !decoded.includes("\x1b")) {
1223          return decoded;
1224        }
1225        return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
1226      } catch (ex) {
1227        warn(`stringToPDFString: "${ex}".`);
1228      }
1229    }
1230  }
1231  const strBuf = [];
1232  for (let i = 0, ii = str.length; i < ii; i++) {
1233    const charCode = str.charCodeAt(i);
1234    if (!keepEscapeSequence && charCode === 0x1b) {
1235      while (++i < ii && str.charCodeAt(i) !== 0x1b) {}
1236      continue;
1237    }
1238    const code = PDFStringTranslateTable[charCode];
1239    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1240  }
1241  return strBuf.join("");
1242}
1243
1244;// ./src/core/core_utils.js
1245
1246
1247
1248
1249const PDF_VERSION_REGEXP = /^[1-9]\.\d$/;
1250const MAX_INT_32 = 2 ** 31 - 1;
1251const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
1252const RESOURCES_KEYS_OPERATOR_LIST = ["ColorSpace", "ExtGState", "Font", "Pattern", "Properties", "Shading", "XObject"];
1253const RESOURCES_KEYS_TEXT_CONTENT = ["ExtGState", "Font", "Properties", "XObject"];
1254function getLookupTableFactory(initializer) {
1255  let lookup;
1256  return function () {
1257    if (initializer) {
1258      lookup = Object.create(null);
1259      initializer(lookup);
1260      initializer = null;
1261    }
1262    return lookup;
1263  };
1264}
1265class MissingDataException extends BaseException {
1266  constructor(begin, end) {
1267    super(`Missing data [${begin}, ${end})`, "MissingDataException");
1268    this.begin = begin;
1269    this.end = end;
1270  }
1271}
1272class ParserEOFException extends BaseException {
1273  constructor(msg) {
1274    super(msg, "ParserEOFException");
1275  }
1276}
1277class XRefEntryException extends BaseException {
1278  constructor(msg) {
1279    super(msg, "XRefEntryException");
1280  }
1281}
1282class XRefParseException extends BaseException {
1283  constructor(msg) {
1284    super(msg, "XRefParseException");
1285  }
1286}
1287function arrayBuffersToBytes(arr) {
1288  const length = arr.length;
1289  if (length === 0) {
1290    return new Uint8Array(0);
1291  }
1292  if (length === 1) {
1293    return new Uint8Array(arr[0]);
1294  }
1295  let dataLength = 0;
1296  for (let i = 0; i < length; i++) {
1297    dataLength += arr[i].byteLength;
1298  }
1299  const data = new Uint8Array(dataLength);
1300  let pos = 0;
1301  for (let i = 0; i < length; i++) {
1302    const item = new Uint8Array(arr[i]);
1303    data.set(item, pos);
1304    pos += item.byteLength;
1305  }
1306  return data;
1307}
1308async function fetchBinaryData(url) {
1309  const response = await fetch(url);
1310  if (!response.ok) {
1311    throw new Error(`Failed to fetch file "${url}" with "${response.statusText}".`);
1312  }
1313  return response.bytes();
1314}
1315function getInheritableProperty({
1316  dict,
1317  key,
1318  getArray = false,
1319  stopWhenFound = true
1320}) {
1321  let values;
1322  const visited = new RefSet();
1323  while (dict instanceof Dict && !(dict.objId && visited.has(dict.objId))) {
1324    if (dict.objId) {
1325      visited.put(dict.objId);
1326    }
1327    const value = getArray ? dict.getArray(key) : dict.get(key);
1328    if (value !== undefined) {
1329      if (stopWhenFound) {
1330        return value;
1331      }
1332      (values ||= []).push(value);
1333    }
1334    dict = dict.get("Parent");
1335  }
1336  return values;
1337}
1338function getParentToUpdate(dict, ref, xref) {
1339  const visited = new RefSet();
1340  const firstDict = dict;
1341  const result = {
1342    dict: null,
1343    ref: null
1344  };
1345  while (dict instanceof Dict && !visited.has(ref)) {
1346    visited.put(ref);
1347    if (dict.has("T")) {
1348      break;
1349    }
1350    ref = dict.getRaw("Parent");
1351    if (!(ref instanceof Ref)) {
1352      return result;
1353    }
1354    dict = xref.fetch(ref);
1355  }
1356  if (dict instanceof Dict && dict !== firstDict) {
1357    result.dict = dict;
1358    result.ref = ref;
1359  }
1360  return result;
1361}
1362function deepCompare(a, b) {
1363  if (a === b) {
1364    return true;
1365  }
1366  if (a instanceof Ref && b instanceof Ref) {
1367    return isRefsEqual(a, b);
1368  }
1369  if (a instanceof Name && b instanceof Name) {
1370    return a.name === b.name;
1371  }
1372  if (a instanceof Dict && b instanceof Dict) {
1373    if (a.size !== b.size) {
1374      return false;
1375    }
1376    for (const [key, value1] of a.getRawEntries()) {
1377      const value2 = b.getRaw(key);
1378      if (value2 === undefined || !deepCompare(value1, value2)) {
1379        return false;

1380      }
1381    }
1382    return true;
1383  }
1384  if (Array.isArray(a) && Array.isArray(b)) {
1385    if (a.length !== b.length) {
1386      return false;
1387    }
1388    for (let i = 0, ii = a.length; i < ii; i++) {
1389      if (!deepCompare(a[i], b[i])) {
1390        return false;
1391      }
1392    }
1393    return true;
1394  }
1395  return false;
1396}
1397const ROMAN_NUMBER_MAP = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
1398function toRomanNumerals(number, lowerCase = false) {
1399  assert(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
1400  const roman = "M".repeat(number / 1000 | 0) + ROMAN_NUMBER_MAP[number % 1000 / 100 | 0] + ROMAN_NUMBER_MAP[10 + (number % 100 / 10 | 0)] + ROMAN_NUMBER_MAP[20 + number % 10];
1401  return lowerCase ? roman.toLowerCase() : roman;
1402}
1403function isWhiteSpace(ch) {
1404  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
1405}
1406function isBooleanArray(arr, len) {
1407  return Array.isArray(arr) && (len === null || arr.length === len) && arr.every(x => typeof x === "boolean");
1408}
1409function isNumberArray(arr, len) {
1410  if (Array.isArray(arr)) {
1411    return (len === null || arr.length === len) && arr.every(x => typeof x === "number");
1412  }
1413  return ArrayBuffer.isView(arr) && !(arr instanceof BigInt64Array || arr instanceof BigUint64Array) && (len === null || arr.length === len);
1414}
1415function lookupMatrix(arr, fallback) {
1416  return isNumberArray(arr, 6) ? arr : fallback;
1417}
1418function lookupRect(arr, fallback) {
1419  return isNumberArray(arr, 4) ? arr : fallback;
1420}
1421function lookupNormalRect(arr, fallback) {
1422  return isNumberArray(arr, 4) ? Util.normalizeRect(arr) : fallback;
1423}
1424function parseXFAPath(path) {
1425  const positionPattern = /(.+)\[(\d+)\]$/;
1426  return path.split(".").map(component => {
1427    const m = component.match(positionPattern);
1428    if (m) {
1429      return {
1430        name: m[1],
1431        pos: parseInt(m[2], 10)
1432      };
1433    }
1434    return {
1435      name: component,
1436      pos: 0
1437    };
1438  });
1439}
1440function escapePDFName(str) {
1441  const buffer = [];
1442  let start = 0;
1443  for (let i = 0, ii = str.length; i < ii; i++) {
1444    const char = str.charCodeAt(i);
1445    if (char < 0x21 || char > 0x7e || char === 0x23 || char === 0x28 || char === 0x29 || char === 0x3c || char === 0x3e || char === 0x5b || char === 0x5d || char === 0x7b || char === 0x7d || char === 0x2f || char === 0x25) {
1446      if (start < i) {
1447        buffer.push(str.substring(start, i));
1448      }
1449      buffer.push(`#${char.toString(16)}`);
1450      start = i + 1;
1451    }
1452  }
1453  if (buffer.length === 0) {
1454    return str;
1455  }
1456  if (start < str.length) {
1457    buffer.push(str.substring(start));
1458  }
1459  return buffer.join("");
1460}
1461function escapeString(str) {
1462  return str.replaceAll(/([()\\\n\r])/g, match => {
1463    if (match === "\n") {
1464      return "\\n";
1465    } else if (match === "\r") {
1466      return "\\r";
1467    }
1468    return `\\${match}`;
1469  });
1470}
1471function _collectJS(entry, xref, list, parents) {
1472  if (!entry) {
1473    return;
1474  }
1475  let parent = null;
1476  if (entry instanceof Ref) {
1477    if (parents.has(entry)) {
1478      return;
1479    }
1480    parent = entry;
1481    parents.put(parent);
1482    entry = xref.fetch(entry);
1483  }
1484  if (Array.isArray(entry)) {
1485    for (const element of entry) {
1486      _collectJS(element, xref, list, parents);
1487    }
1488  } else if (entry instanceof Dict) {
1489    if (isName(entry.get("S"), "JavaScript")) {
1490      const js = entry.get("JS");
1491      let code;
1492      if (js instanceof BaseStream) {
1493        code = js.getString();
1494      } else if (typeof js === "string") {
1495        code = js;
1496      }
1497      code &&= stringToPDFString(code, true).replaceAll("\x00", "");
1498      if (code) {
1499        list.push(code.trim());
1500      }
1501    }
1502    _collectJS(entry.getRaw("Next"), xref, list, parents);
1503  }
1504  if (parent) {
1505    parents.remove(parent);
1506  }
1507}
1508function collectActions(xref, dict, eventType) {
1509  const actions = Object.create(null);
1510  const additionalActionsDicts = getInheritableProperty({
1511    dict,
1512    key: "AA",
1513    stopWhenFound: false
1514  });
1515  if (additionalActionsDicts) {
1516    for (let i = additionalActionsDicts.length - 1; i >= 0; i--) {
1517      const additionalActions = additionalActionsDicts[i];
1518      if (!(additionalActions instanceof Dict)) {
1519        continue;
1520      }
1521      for (const [key, rawActionDict] of additionalActions.getRawEntries()) {
1522        const action = eventType[key];
1523        if (!action) {
1524          continue;
1525        }
1526        const parents = new RefSet();
1527        const list = [];
1528        _collectJS(rawActionDict, xref, list, parents);
1529        if (list.length > 0) {
1530          actions[action] = list;
1531        }
1532      }
1533    }
1534  }
1535  if (dict.has("A")) {
1536    const actionDict = dict.get("A");
1537    const parents = new RefSet();
1538    const list = [];
1539    _collectJS(actionDict, xref, list, parents);
1540    if (list.length > 0) {
1541      actions.Action = list;
1542    }
1543  }
1544  return objectSize(actions) > 0 ? actions : null;
1545}
1546const XMLEntities = {
1547  0x3c: "&lt;",
1548  0x3e: "&gt;",
1549  0x26: "&amp;",
1550  0x22: "&quot;",
1551  0x27: "&apos;"
1552};
1553function* codePointIter(str) {
1554  for (let i = 0, ii = str.length; i < ii; i++) {
1555    const char = str.codePointAt(i);
1556    if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1557      i++;
1558    }
1559    yield char;
1560  }
1561}
1562function encodeToXmlString(str) {
1563  const buffer = [];
1564  let start = 0;
1565  for (let i = 0, ii = str.length; i < ii; i++) {
1566    const char = str.codePointAt(i);
1567    if (0x20 <= char && char <= 0x7e) {
1568      const entity = XMLEntities[char];
1569      if (entity) {
1570        if (start < i) {
1571          buffer.push(str.substring(start, i));
1572        }
1573        buffer.push(entity);
1574        start = i + 1;
1575      }
1576    } else {
1577      if (start < i) {
1578        buffer.push(str.substring(start, i));
1579      }
1580      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
1581      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1582        i++;
1583      }
1584      start = i + 1;
1585    }
1586  }
1587  if (buffer.length === 0) {
1588    return str;
1589  }
1590  if (start < str.length) {
1591    buffer.push(str.substring(start));
1592  }
1593  return buffer.join("");
1594}
1595function validateFontName(fontFamily, mustWarn = false) {
1596  const m = /^("|').*("|')$/.exec(fontFamily);
1597  if (m && m[1] === m[2]) {
1598    const re = new RegExp(`[^\\\\]${m[1]}`);
1599    if (re.test(fontFamily.slice(1, -1))) {
1600      if (mustWarn) {
1601        warn(`FontFamily contains unescaped ${m[1]}: ${fontFamily}.`);
1602      }
1603      return false;
1604    }
1605  } else {
1606    for (const ident of fontFamily.split(/[ \t]+/)) {
1607      if (/^(?:\d|-[\d-])/.test(ident) || !/^[\w\\-]+$/.test(ident)) {
1608        if (mustWarn) {
1609          warn(`FontFamily contains invalid <custom-ident>: ${fontFamily}.`);
1610        }
1611        return false;
1612      }
1613    }
1614  }
1615  return true;
1616}
1617function validateCSSFont(cssFontInfo) {
1618  const DEFAULT_CSS_FONT_OBLIQUE = "14";
1619  const DEFAULT_CSS_FONT_WEIGHT = "400";
1620  const CSS_FONT_WEIGHT_VALUES = new Set(["100", "200", "300", "400", "500", "600", "700", "800", "900", "1000", "normal", "bold", "bolder", "lighter"]);
1621  const {
1622    fontFamily,
1623    fontWeight,
1624    italicAngle
1625  } = cssFontInfo;
1626  if (!validateFontName(fontFamily, true)) {
1627    return false;
1628  }
1629  const weight = fontWeight ? fontWeight.toString() : "";
1630  cssFontInfo.fontWeight = CSS_FONT_WEIGHT_VALUES.has(weight) ? weight : DEFAULT_CSS_FONT_WEIGHT;
1631  const angle = parseFloat(italicAngle);
1632  cssFontInfo.italicAngle = isNaN(angle) || angle < -90 || angle > 90 ? DEFAULT_CSS_FONT_OBLIQUE : italicAngle.toString();
1633  return true;
1634}
1635function recoverJsURL(str) {
1636  const URL_OPEN_METHODS = ["app.launchURL", "window.open", "xfa.host.gotoURL"];
1637  const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").replaceAll(".", "\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
1638  const jsUrl = regex.exec(str);
1639  if (jsUrl?.[2]) {
1640    return {
1641      url: jsUrl[2],
1642      newWindow: jsUrl[1] === "app.launchURL" && jsUrl[3] === "true"
1643    };
1644  }
1645  return null;
1646}
1647function numberToString(value) {
1648  if (Number.isInteger(value)) {
1649    return value.toString();
1650  }
1651  const roundedValue = Math.round(value * 100);
1652  if (roundedValue % 100 === 0) {
1653    return (roundedValue / 100).toString();
1654  }
1655  if (roundedValue % 10 === 0) {
1656    return value.toFixed(1);
1657  }
1658  return value.toFixed(2);
1659}
1660function getNewAnnotationsMap(annotationStorage) {
1661  if (!annotationStorage) {
1662    return null;
1663  }
1664  const newAnnotationsByPage = new Map();
1665  for (const [key, value] of annotationStorage) {
1666    if (!key.startsWith(AnnotationEditorPrefix)) {
1667      continue;
1668    }
1669    newAnnotationsByPage.getOrInsertComputed(value.pageIndex, makeArr).push(value);
1670  }
1671  return newAnnotationsByPage.size > 0 ? newAnnotationsByPage : null;
1672}
1673function getModificationDate(date = new Date()) {
1674  if (!(date instanceof Date)) {
1675    date = new Date(date);
1676  }
1677  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")];
1678  return buffer.join("");
1679}
1680function getRotationMatrix(rotation, width, height) {
1681  switch (rotation) {
1682    case 90:
1683      return [0, 1, -1, 0, width, 0];
1684    case 180:
1685      return [-1, 0, 0, -1, width, height];
1686    case 270:
1687      return [0, -1, 1, 0, 0, height];
1688    default:
1689      throw new Error("Invalid rotation");
1690  }
1691}
1692function getSizeInBytes(x) {
1693  return Math.ceil(Math.ceil(Math.log2(1 + x)) / 8);
1694}
1695
1696;// ./external/qcms/qcms_utils.js
1697class QCMS {
1698  static #memoryArray = null;
1699  static _memory = null;
1700  static _mustAddAlpha = false;
1701  static _destBuffer = null;
1702  static _destOffset = 0;
1703  static _destLength = 0;
1704  static _cssColor = "";
1705  static _makeHexColor = null;
1706  static get _memoryArray() {
1707    const array = this.#memoryArray;
1708    if (array?.byteLength) {
1709      return array;
1710    }
1711    return this.#memoryArray = new Uint8Array(this._memory.buffer);
1712  }
1713}
1714function copy_result(ptr, len) {
1715  const {
1716    _mustAddAlpha,
1717    _destBuffer,
1718    _destOffset,
1719    _destLength,
1720    _memoryArray
1721  } = QCMS;
1722  if (len === _destLength) {
1723    _destBuffer.set(_memoryArray.subarray(ptr, ptr + len), _destOffset);
1724    return;
1725  }
1726  if (_mustAddAlpha) {
1727    for (let i = ptr, ii = ptr + len, j = _destOffset; i < ii; i += 3, j += 4) {
1728      _destBuffer[j] = _memoryArray[i];
1729      _destBuffer[j + 1] = _memoryArray[i + 1];
1730      _destBuffer[j + 2] = _memoryArray[i + 2];
1731      _destBuffer[j + 3] = 255;
1732    }
1733  } else {

1875
1876  wasm = instance.exports;
1877  wasmModule = module;
1878  cachedUint8ArrayMemory0 = null;
1879  wasm.__wbindgen_start();
1880  return wasm;
1881}
1882async function __wbg_load(module, imports) {
1883  if (typeof Response === 'function' && module instanceof Response) {
1884    if (typeof WebAssembly.instantiateStreaming === 'function') {
1885      try {
1886        return await WebAssembly.instantiateStreaming(module, imports);
1887      } catch (e) {
1888        const validResponse = module.ok && expectedResponseType(module.type);
1889        if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
1890          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
1891        } else {
1892          throw e;
1893        }
1894      }
1895    }
1896    const bytes = await module.arrayBuffer();
1897    return await WebAssembly.instantiate(bytes, imports);
1898  } else {
1899    const instance = await WebAssembly.instantiate(module, imports);
1900    if (instance instanceof WebAssembly.Instance) {
1901      return {
1902        instance,
1903        module
1904      };
1905    } else {
1906      return instance;
1907    }
1908  }
1909  function expectedResponseType(type) {
1910    switch (type) {
1911      case 'basic':
1912      case 'cors':
1913      case 'default':
1914        return true;
1915    }
1916    return false;
1917  }
1918}
1919function initSync(module) {
1920  if (wasm !== undefined) return wasm;
1921  if (module !== undefined) {
1922    if (Object.getPrototypeOf(module) === Object.prototype) {
1923      ({
1924        module
1925      } = module);
1926    } else {
1927      console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
1928    }
1929  }
1930  const imports = __wbg_get_imports();
1931  if (!(module instanceof WebAssembly.Module)) {
1932    module = new WebAssembly.Module(module);
1933  }
1934  const instance = new WebAssembly.Instance(module, imports);
1935  return __wbg_finalize_init(instance, module);
1936}
1937async function __wbg_init(module_or_path) {
1938  if (wasm !== undefined) return wasm;
1939  if (module_or_path !== undefined) {
1940    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
1941      ({
1942        module_or_path
1943      } = module_or_path);
1944    } else {
1945      console.warn('using deprecated parameters for the initialization function; pass a single object instead');
1946    }
1947  }
1948  const imports = __wbg_get_imports();
1949  if (typeof module_or_path === 'string' || typeof Request === 'function' && module_or_path instanceof Request || typeof URL === 'function' && module_or_path instanceof URL) {
1950    module_or_path = fetch(module_or_path);
1951  }
1952  const {
1953    instance,
1954    module
1955  } = await __wbg_load(await module_or_path, imports);
1956  return __wbg_finalize_init(instance, module);
1957}
1958
1959;// ./src/shared/math_clamp.js
1960function MathClamp(v, min, max) {
1961  return Math.min(Math.max(v, min), max);
1962}
1963
1964;// ./src/core/colorspace.js
1965
1966
1967
1968function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
1969  const COMPONENTS = 3;
1970  alpha01 = alpha01 !== 1 ? 0 : alpha01;
1971  const xRatio = w1 / w2;
1972  const yRatio = h1 / h2;
1973  let newIndex = 0,
1974    oldIndex;
1975  const xScaled = new Uint16Array(w2);
1976  const w1Scanline = w1 * COMPONENTS;
1977  for (let i = 0; i < w2; i++) {
1978    xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
1979  }
1980  for (let i = 0; i < h2; i++) {
1981    const py = Math.floor(i * yRatio) * w1Scanline;
1982    for (let j = 0; j < w2; j++) {
1983      oldIndex = py + xScaled[j];
1984      dest[newIndex++] = src[oldIndex++];
1985      dest[newIndex++] = src[oldIndex++];
1986      dest[newIndex++] = src[oldIndex++];
1987      newIndex += alpha01;
1988    }
1989  }
1990}
1991function resizeRgbaImage(src, dest, w1, h1, w2, h2, alpha01) {
1992  const xRatio = w1 / w2;
1993  const yRatio = h1 / h2;
1994  let newIndex = 0;
1995  const xScaled = new Uint16Array(w2);
1996  if (alpha01 === 1) {
1997    for (let i = 0; i < w2; i++) {
1998      xScaled[i] = Math.floor(i * xRatio);
1999    }
2000    const src32 = new Uint32Array(src.buffer);
2001    const dest32 = new Uint32Array(dest.buffer);
2002    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2003    for (let i = 0; i < h2; i++) {
2004      const buf = src32.subarray(Math.floor(i * yRatio) * w1);
2005      for (let j = 0; j < w2; j++) {
2006        dest32[newIndex++] |= buf[xScaled[j]] & rgbMask;
2007      }
2008    }
2009  } else {
2010    const COMPONENTS = 4;
2011    const w1Scanline = w1 * COMPONENTS;
2012    for (let i = 0; i < w2; i++) {
2013      xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
2014    }
2015    for (let i = 0; i < h2; i++) {
2016      const buf = src.subarray(Math.floor(i * yRatio) * w1Scanline);
2017      for (let j = 0; j < w2; j++) {
2018        const oldIndex = xScaled[j];
2019        dest[newIndex++] = buf[oldIndex];
2020        dest[newIndex++] = buf[oldIndex + 1];
2021        dest[newIndex++] = buf[oldIndex + 2];
2022      }
2023    }
2024  }
2025}
2026function copyRgbaImage(src, dest, alpha01) {
2027  if (alpha01 === 1) {
2028    const src32 = new Uint32Array(src.buffer);
2029    const dest32 = new Uint32Array(dest.buffer);
2030    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2031    for (let i = 0, ii = src32.length; i < ii; i++) {
2032      dest32[i] |= src32[i] & rgbMask;
2033    }
2034  } else {
2035    let j = 0;
2036    for (let i = 0, ii = src.length; i < ii; i += 4) {
2037      dest[j++] = src[i];
2038      dest[j++] = src[i + 1];
2039      dest[j++] = src[i + 2];
2040    }
2041  }
2042}
2043function isDefaultDecodeHelper(decode, expectedLen) {
2044  if (!Array.isArray(decode)) {
2045    return true;
2046  }
2047  const decodeLen = decode.length;
2048  if (decodeLen < expectedLen) {
2049    warn("Decode map length is too short.");
2050    return true;
2051  }
2052  if (decodeLen > expectedLen) {
2053    info("Truncating too long decode map.");
2054    decode.length = expectedLen;
2055  }
2056  return false;
2057}
2058class ColorSpace {
2059  static #rgbBuf = new Uint8ClampedArray(3);
2060  constructor(name, numComps) {
2061    this.name = name;
2062    this.numComps = numComps;
2063  }
2064  getRgb(src, srcOffset, output = new Uint8ClampedArray(3)) {
2065    this.getRgbItem(src, srcOffset, output, 0);
2066    return output;
2067  }
2068  getRgbHex(src, srcOffset) {
2069    const buffer = this.getRgb(src, srcOffset, ColorSpace.#rgbBuf);
2070    return Util.makeHexColor(buffer[0], buffer[1], buffer[2]);
2071  }
2072  getRgbItem(src, srcOffset, dest, destOffset) {
2073    unreachable("Should not call ColorSpace.getRgbItem");
2074  }
2075  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2076    unreachable("Should not call ColorSpace.getRgbBuffer");
2077  }
2078  get

2078OutputLength(inputLength, alpha01) {
2079    unreachable("Should not call ColorSpace.getOutputLength");
2080  }
2081  isPassthrough(bits) {
2082    return false;
2083  }
2084  isDefaultDecode(decode, bpc) {
2085    return ColorSpace.isDefaultDecode(decode, this.numComps);
2086  }
2087  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2088    const count = originalWidth * originalHeight;
2089    let rgbBuf = null;
2090    const numComponentColors = 1 << bpc;
2091    const needsResizing = originalHeight !== height || originalWidth !== width;
2092    if (this.isPassthrough(bpc)) {
2093      rgbBuf = comps;
2094    } else if (this.numComps === 1 && count > numComponentColors && this.name !== "DeviceGray" && this.name !== "DeviceRGB") {
2095      const allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : new Uint16Array(numComponentColors);
2096      for (let i = 0; i < numComponentColors; i++) {
2097        allColors[i] = i;
2098      }
2099      const colorMap = new Uint8ClampedArray(numComponentColors * 3);
2100      this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc, 0);
2101      if (!needsResizing) {
2102        let destPos = 0;
2103        for (let i = 0; i < count; ++i) {
2104          const key = comps[i] * 3;
2105          dest[destPos++] = colorMap[key];
2106          dest[destPos++] = colorMap[key + 1];
2107          dest[destPos++] = colorMap[key + 2];
2108          destPos += alpha01;
2109        }
2110      } else {
2111        rgbBuf = new Uint8Array(count * 3);
2112        let rgbPos = 0;
2113        for (let i = 0; i < count; ++i) {
2114          const key = comps[i] * 3;
2115          rgbBuf[rgbPos++] = colorMap[key];
2116          rgbBuf[rgbPos++] = colorMap[key + 1];
2117          rgbBuf[rgbPos++] = colorMap[key + 2];
2118        }
2119      }
2120    } else if (!needsResizing) {
2121      this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, alpha01);
2122    } else {
2123      rgbBuf = new Uint8ClampedArray(count * 3);
2124      this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, 0);
2125    }
2126    if (rgbBuf) {
2127      if (needsResizing) {
2128        resizeRgbImage(rgbBuf, dest, originalWidth, originalHeight, width, height, alpha01);
2129      } else {
2130        let destPos = 0,
2131          rgbPos = 0;
2132        for (let i = 0, ii = width * actualHeight; i < ii; i++) {
2133          dest[destPos++] = rgbBuf[rgbPos++];
2134          dest[destPos++] = rgbBuf[rgbPos++];
2135          dest[destPos++] = rgbBuf[rgbPos++];
2136          destPos += alpha01;
2137        }
2138      }
2139    }
2140  }
2141  get usesZeroToOneRange() {
2142    return shadow(this, "usesZeroToOneRange", true);
2143  }
2144  static isDefaultDecode(decode, numComps) {
2145    if (isDefaultDecodeHelper(decode, numComps * 2)) {
2146      return true;
2147    }
2148    for (let i = 0, ii = decode.length; i < ii; i += 2) {
2149      if (decode[i] !== 0 || decode[i + 1] !== 1) {
2150        return false;
2151      }
2152    }
2153    return true;
2154  }
2155}
2156class AlternateCS extends ColorSpace {
2157  constructor(numComps, base, tintFn) {
2158    super("Alternate", numComps);
2159    this.base = base;
2160    this.tintFn = tintFn;
2161    this.tmpBuf = new Float32Array(base.numComps);
2162  }
2163  getRgbItem(src, srcOffset, dest, destOffset) {
2164    const tmpBuf = this.tmpBuf;
2165    this.tintFn(src, srcOffset, tmpBuf, 0);
2166    this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
2167  }
2168  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2169    const tintFn = this.tintFn;
2170    const base = this.base;
2171    const scale = 1 / ((1 << bits) - 1);
2172    const baseNumComps = base.numComps;
2173    const usesZeroToOneRange = base.usesZeroToOneRange;
2174    const isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) && alpha01 === 0;

2175    let pos = isPassthrough ? destOffset : 0;
2176    const baseBuf = isPassthrough ? dest : new Uint8ClampedArray(baseNumComps * count);
2177    const numComps = this.numComps;
2178    const scaled = new Float32Array(numComps);
2179    const tinted = new Float32Array(baseNumComps);
2180    let i, j;
2181    for (i = 0; i < count; i++) {
2182      for (j = 0; j < numComps; j++) {
2183        scaled[j] = src[srcOffset++] * scale;
2184      }
2185      tintFn(scaled, 0, tinted, 0);
2186      if (usesZeroToOneRange) {
2187        for (j = 0; j < baseNumComps; j++) {
2188          baseBuf[pos++] = tinted[j] * 255;
2189        }
2190      } else {
2191        base.getRgbItem(tinted, 0, baseBuf, pos);
2192        pos += baseNumComps;
2193      }
2194    }
2195    if (!isPassthrough) {
2196      base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);
2197    }
2198  }
2199  getOutputLength(inputLength, alpha01) {
2200    return this.base.getOutputLength(inputLength * this.base.numComps / this.numComps, alpha01);
2201  }
2202}
2203class PatternCS extends ColorSpace {
2204  constructor(baseCS) {
2205    super("Pattern", null);
2206    this.base = baseCS;
2207  }
2208  isDefaultDecode(decode, bpc) {
2209    unreachable("Should not call PatternCS.isDefaultDecode");
2210  }
2211}
2212class IndexedCS extends ColorSpace {
2213  constructor(base, highVal, lookup) {
2214    super("Indexed", 1);
2215    this.base = base;
2216    this.highVal = highVal;
2217    const length = base.numComps * (highVal + 1);
2218    this.lookup = new Uint8Array(length);
2219    if (lookup instanceof BaseStream) {
2220      const bytes = lookup.getBytes(length);
2221      this.lookup.set(bytes);
2222    } else if (typeof lookup === "string") {
2223      for (let i = 0; i < length; ++i) {
2224        this.lookup[i] = lookup.charCodeAt(i) & 0xff;
2225      }
2226    } else {
2227      throw new FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);
2228    }
2229  }
2230  getRgbItem(src, srcOffset, dest, destOffset) {
2231    const {
2232      base,
2233      highVal,
2234      lookup
2235    } = this;
2236    const start = MathClamp(Math.round(src[srcOffset]), 0, highVal) * base.numComps;
2237    base.getRgbBuffer(lookup, start, 1, dest, destOffset, 8, 0);
2238  }
2239  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2240    const {
2241      base,
2242      highVal,
2243      lookup
2244    } = this;
2245    const {
2246      numComps
2247    } = base;
2248    const outputDelta = base.getOutputLength(numComps, alpha01);
2249    for (let i = 0; i < count; ++i) {
2250      const lookupPos = MathClamp(Math.round(src[srcOffset++]), 0, highVal) * numComps;
2251      base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);
2252      destOffset += outputDelta;
2253    }
2254  }
2255  getOutputLength(inputLength, alpha01) {
2256    return this.base.getOutputLength(inputLength * this.base.numComps, alpha01);
2257  }
2258  isDefaultDecode(decode, bpc) {
2259    if (isDefaultDecodeHelper(decode, 2)) {
2260      return true;
2261    }
2262    if (!Number.isInteger(bpc) || bpc < 1) {
2263      warn("Bits per component is not correct");
2264      return true;
2265    }
2266    return decode[0] === 0 && decode[1] === (1 << bpc) - 1;
2267  }
2268}
2269class DeviceGrayCS extends ColorSpace {
2270  constructor() {
2271    super("DeviceGray", 1);
2272  }
2273  getRgbItem(src, srcOffset, dest, destOffset) {
2274    const c = src[srcOffset] * 255;
2275    dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;
2276  }
2277  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2278    const scale = 255 / ((1 << bits) - 1);
2279    let j = srcOffset,
2280      q = destOffset;
2281    for (let i = 0; i < count; ++i) {
2282      const c = scale * src[j++];
2283      dest[q++] = c;
2284      dest[q++] = c;
2285      dest[q++] = c;
2286      q += alpha01;
2287    }
2288  }
2289  getOutputLength(inputLength, alpha01) {
2290    return inputLength * (3 + alpha01);
2291  }
2292}
2293class DeviceRgbCS extends ColorSpace {
2294  constructor() {
2295    super("DeviceRGB", 3);
2296  }
2297  getRgbItem(src, srcOffset, dest, destOffset) {
2298    dest[destOffset] = src[srcOffset] * 255;
2299    dest[destOffset + 1] = src[srcOffset + 1] * 255;
2300    dest[destOffset + 2] = src[srcOffset + 2] * 255;
2301  }
2302  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2303    if (bits === 8 && alpha01 === 0) {
2304      dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);
2305      return;
2306    }
2307    const scale = 255 / ((1 << bits) - 1);
2308    let j = srcOffset,
2309      q = destOffset;
2310    for (let i = 0; i < count; ++i) {
2311      dest[q++] = scale * src[j++];
2312      dest[q++] = scale * src[j++];
2313      dest[q++] = scale * src[j++];
2314      q += alpha01;
2315    }
2316  }
2317  getOutputLength(inputLength, alpha01) {
2318    return inputLength * (3 + alpha01) / 3 | 0;
2319  }
2320  isPassthrough(bits) {
2321    return bits === 8;
2322  }
2323}
2324class DeviceRgbaCS extends ColorSpace {
2325  constructor() {
2326    super("DeviceRGBA", 4);
2327  }
2328  getOutputLength(inputLength, _alpha01) {
2329    return inputLength * 4;
2330  }
2331  isPassthrough(bits) {
2332    return bits === 8;
2333  }
2334  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2335    if (originalHeight !== height || originalWidth !== width) {
2336      resizeRgbaImage(comps, dest, originalWidth, originalHeight, width, height, alpha01);
2337    } else {
2338      copyRgbaImage(comps, dest, alpha01);
2339    }
2340  }
2341}
2342class DeviceCmykCS extends ColorSpace {
2343  constructor() {
2344    super("DeviceCMYK", 4);
2345  }
2346  #toRgb(src, srcOffset, srcScale, dest, destOffset) {
2347    const c = src[srcOffset] * srcScale;
2348    const m = src[srcOffset + 1] * srcScale;
2349    const y = src[srcOffset + 2] * srcScale;
2350    const k = src[srcOffset + 3] * srcScale;
2351    dest[destOffset] = 255 + c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k + -285.2331026137004) + m * (1.7149763477362134 * m - 5.6096736904047315 * y + -17.873870861415444 * k - 5.497006427196366) + y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) + k * (-21.86122147463605 * k - 189.48180835922747);
2352    dest[destOffset + 1] = 255 + c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k + -79.2970844816548) + m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) + y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) + k * (-20.737325471181034 * k - 187.80453709719578);
2353    dest[destOffset + 2] = 255 + c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k + -14.183576799673286) + m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) + y * (0.03296041114873217 * y + 115.60384449646641 * k + -193.58209356861505) + k * (-22.33816807309886 * k - 180.12613974708367);
2354  }
2355  getRgbItem(src, srcOffset, dest, destOffset) {
2356    this.#toRgb(src, srcOffset, 1, dest, destOffset);
2357  }
2358  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2359    const scale = 1 / ((1 << bits) - 1);
2360    for (let i = 0; i < count; i++) {
2361      this.#toRgb(src, srcOffset, scale, dest, destOffset);
2362      srcOffset += 4;
2363      destOffset += 3 + alpha01;
2364    }
2365  }
2366  getOutputLength(inputLength, alpha01) {
2367    return inputLength / 4 * (3 + alpha01) | 0;
2368  }
2369}
2370class CalGrayCS extends ColorSpace {
2371  constructor(whitePoint, blackPoint, gamma) {
2372    super("CalGray", 1);
2373    if (!whitePoint) {
2374      throw new FormatError("WhitePoint missing - required for color space CalGray");
2375    }
2376    [this.XW, this.YW, this.ZW] = whitePoint;
2377    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2378    this.G = gamma || 1;
2379    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2380      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2381    }
2382    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2383      info(`Invalid BlackPoint for ${this.name}, falling back to default.`);
2384      this.XB = this.YB = this.ZB = 0;
2385    }
2386    if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {
2387      warn(`${this.name}, BlackPoint: XB: ${this.XB}, YB: ${this.YB}, ` + `ZB: ${this.ZB}, only default values are supported.`);
2388    }
2389    if (this.G < 1) {
2390      info(`Invalid Gamma: ${this.G} for ${this.name}, falling back to default.`);
2391      this.G = 1;
2392    }
2393  }
2394  #toRgb(src, srcOffset, dest, destOffset, scale) {
2395    const A = src[srcOffset] * scale;
2396    const AG = A ** this.G;
2397    const L = this.YW * AG;
2398    const val = Math.max(295.8 * L ** 0.3333333333333333 - 40.8, 0);
2399    dest[destOffset] = val;
2400    dest[destOffset + 1] = val;
2401    dest[destOffset + 2] = val;
2402  }
2403  getRgbItem(src, srcOffset, dest, destOffset) {
2404    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2405  }
2406  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2407    const scale = 1 / ((1 << bits) - 1);
2408    for (let i = 0; i < count; ++i) {
2409      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2410      srcOffset += 1;
2411      destOffset += 3 + alpha01;
2412    }
2413  }
2414  getOutputLength(inputLength, alpha01) {
2415    return inputLength * (3 + alpha01);
2416  }
2417}
2418class CalRGBCS extends ColorSpace {
2419  static #BRADFORD_SCALE_MATRIX = new Float32Array([0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296]);
2420  static #BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([0.9869929, -0.1470543, 0.1599627, 0.4323053, 0.5183603, 0.0492912, -0.0085287, 0.0400428, 0.9684867]);
2421  static #SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([3.2404542, -1.5371385, -0.4985314, -0.9692660, 1.8760108, 0.0415560, 0.0556434, -0.2040259, 1.0572252]);
2422  static #FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
2423  static #tempNormalizeMatrix = new Float32Array(3);
2424  static #tempConvertMatrix1 = new Float32Array(3);
2425  static #tempConvertMatrix2 = new Float32Array(3);
2426  static #DECODE_L_CONSTANT = ((8 + 16) / 116) ** 3 / 8.0;
2427  constructor(whitePoint, blackPoint, gamma, matrix) {
2428    super("CalRGB", 3);
2429    if (!whitePoint) {
2430      throw new FormatError("WhitePoint missing - required for color space CalRGB");
2431    }
2432    const [XW, YW, ZW] = this.whitePoint = whitePoint;
2433    const [XB, YB, ZB] = this.blackPoint = blackPoint || new Float32Array(3);
2434    [this.GR, this.GG, this.GB] = gamma || new Float32Array([1, 1, 1]);
2435    [this.MXA, this.MYA, this.MZA, this.MXB, this.MYB, this.MZB, this.MXC, this.MYC, this.MZC] = matrix || new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
2436    if (XW < 0 || ZW < 0 || YW !== 1) {
2437      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2438    }
2439    if (XB < 0 || YB < 0 || ZB < 0) {
2440      info(`Invalid BlackPoint for ${this.name} [${XB}, ${YB}, ${ZB}], ` + "falling back to default.");
2441      this.blackPoint = new Float32Array(3);
2442    }
2443    if (this.GR < 0 || this.GG < 0 || this.GB < 0) {
2444      info(`Invalid Gamma [${this.GR}, ${this.GG}, ${this.GB}] for ` + `${this.name}, falling back to default.`);
2445      this.GR = this.GG = this.GB = 1;
2446    }
2447  }
2448  #matrixProduct(a, b, result) {
2449    result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2450    result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
2451    result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
2452  }
2453  #toFlat(sourceWhitePoint, LMS, result) {
2454    result[0] = LMS[0] * 1 / sourceWhitePoint[0];
2455    result[1] = LMS[1] * 1 / sourceWhitePoint[1];
2456    result[2] = LMS[2] * 1 / sourceWhitePoint[2];
2457  }
2458  #toD65(sourceWhitePoint, LMS, result) {
2459    const D65X = 0.95047;
2460    const D65Y = 1;
2461    const D65Z = 1.08883;
2462    result[0] = LMS[0] * D65X / sourceWhitePoint[0];
2463    result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
2464    result[2] = LMS[2] * D65Z / sourceWhitePoint[2];
2465  }
2466  #sRGBTransferFunction(color) {
2467    if (color <= 0.0031308) {
2468      return MathClamp(12.92 * color, 0, 1);
2469    }
2470    if (color >= 0.99554525) {
2471      return 1;
2472    }
2473    return MathClamp((1 + 0.055) * color ** (1 / 2.4) - 0.055, 0, 1);
2474  }
2475  #decodeL(L) {
2476    if (L < 0) {
2477      return -this.#decodeL(-L);
2478    }
2479    if (L > 8.0) {
2480      return ((L + 16) / 116) ** 3;
2481    }
2482    return L * CalRGBCS.#DECODE_L_CONSTANT;
2483  }
2484  #compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
2485    if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {
2486      result[0] = XYZ_Flat[0];
2487      result[1] = XYZ_Flat[1];
2488      result[2] = XYZ_Flat[2];
2489      return;
2490    }
2491    const zeroDecodeL = this.#decodeL(0);
2492    const X_DST = zeroDecodeL;
2493    const X_SRC = this.#decodeL(sourceBlackPoint[0]);
2494    const Y_DST = zeroDecodeL;
2495    const Y_SRC = this.#decodeL(sourceBlackPoint[1]);
2496    const Z_DST = zeroDecodeL;
2497    const Z_SRC = this.#decodeL(sourceBlackPoint[2]);
2498    const X_Scale = (1 - X_DST) / (1 - X_SRC);
2499    const X_Offset = 1 - X_Scale;
2500    const Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
2501    const Y_Offset = 1 - Y_Scale;
2502    const Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
2503    const Z_Offset = 1 - Z_Scale;
2504    result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
2505    result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
2506    result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
2507  }
2508  #normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
2509    if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
2510      result[0] = XYZ_In[0];
2511      result[1] = XYZ_In[1];
2512      result[2] = XYZ_In[2];
2513      return;
2514    }
2515    const LMS = result;
2516    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2517    const LMS_Flat = CalRGBCS.#tempNormalizeMatrix;
2518    this.#toFlat(sourceWhitePoint, LMS, LMS_Flat);
2519    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
2520  }
2521  #normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
2522    const LMS = result;
2523    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2524    const LMS_D65 = CalRGBCS.#tempNormalizeMatrix;
2525    this.#toD65(sourceWhitePoint, LMS, LMS_D65);
2526    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
2527  }
2528  #toRgb(src, srcOffset, dest, destOffset, scale) {
2529    const A = MathClamp(src[srcOffset] * scale, 0, 1);
2530    const B = MathClamp(src[srcOffset + 1] * scale, 0, 1);
2531    const C = MathClamp(src[srcOffset + 2] * scale, 0, 1);
2532    const AGR = A === 1 ? 1 : A ** this.GR;
2533    const BGG = B === 1 ? 1 : B ** this.GG;
2534    const CGB = C === 1 ? 1 : C ** this.GB;
2535    const X = this.MXA * AGR + this.MXB * BGG + this.MXC * CGB;
2536    const Y = this.MYA * AGR + this.MYB * BGG + this.MYC * CGB;
2537    const Z = this.MZA * AGR + this.MZB * BGG + this.MZC * CGB;
2538    const XYZ = CalRGBCS.#tempConvertMatrix1;
2539    XYZ[0] = X;
2540    XYZ[1] = Y;
2541    XYZ[2] = Z;
2542    const XYZ_Flat = CalRGBCS.#tempConvertMatrix2;
2543    this.#normalizeWhitePointToFlat(this.whitePoint, XYZ, XYZ_Flat);
2544    const XYZ_Black = CalRGBCS.#tempConvertMatrix1;
2545    this.#compensateBlackPoint(this.blackPoint, XYZ_Flat, XYZ_Black);
2546    const XYZ_D65 = CalRGBCS.#tempConvertMatrix2;
2547    this.#normalizeWhitePointToD65(CalRGBCS.#FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);
2548    const SRGB = CalRGBCS.#tempConvertMatrix1;
2549    this.#matrixProduct(CalRGBCS.#SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
2550    dest[destOffset] = this.#sRGBTransferFunction(SRGB[0]) * 255;
2551    dest[destOffset + 1] = this.#sRGBTransferFunction(SRGB[1]) * 255;
2552    dest[destOffset + 2] = this.#sRGBTransferFunction(SRGB[2]) * 255;
2553  }
2554  getRgbItem(src, srcOffset, dest, destOffset) {
2555    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2556  }
2557  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2558    const scale = 1 / ((1 << bits) - 1);
2559    for (let i = 0; i < count; ++i) {
2560      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2561      srcOffset += 3;
2562      destOffset += 3 + alpha01;
2563    }
2564  }
2565  getOutputLength(inputLength, alpha01) {
2566    return inputLength * (3 + alpha01) / 3 | 0;
2567  }
2568}
2569class LabCS extends ColorSpace {
2570  constructor(whitePoint, blackPoint, range) {
2571    super("Lab", 3);
2572    if (!whitePoint) {
2573      throw new FormatError("WhitePoint missing - required for color space Lab");
2574    }
2575    [this.XW, this.YW, this.ZW] = whitePoint;
2576    [this.amin, this.amax, this.bmin, this.bmax] = range || [-100, 100, -100, 100];
2577    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2578    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2579      throw new FormatError("Invalid WhitePoint components, no fallback available");
2580    }
2581    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2582      info("Invalid BlackPoint, falling back to default");
2583      this.XB = this.YB = this.ZB = 0;
2584    }
2585    if (this.amin > this.amax || this.bmin > this.bmax) {
2586      info("Invalid Range, falling back to defaults");
2587      this.amin = -100;
2588      this.amax = 100;
2589      this.bmin = -100;
2590      this.bmax = 100;
2591    }
2592  }
2593  #fn_g(x) {
2594    return x >= 6 / 29 ? x ** 3 : 108 / 841 * (x - 4 / 29);
2595  }
2596  #decode(value, high1, low2, high2) {
2597    return low2 + value * (high2 - low2) / high1;
2598  }
2599  #toRgb(src, srcOffset, maxVal, dest, destOffset) {
2600    let Ls = src[srcOffset];
2601    let as = src[srcOffset + 1];
2602    let bs = src[srcOffset + 2];
2603    if (maxVal !== false) {
2604      Ls = this.#decode(Ls, maxVal, 0, 100);
2605      as = this.#decode(as, maxVal, this.amin, this.amax);
2606      bs = this.#decode(bs, maxVal, this.bmin, this.bmax);
2607    }
2608    if (as > this.amax) {
2609      as = this.amax;
2610    } else if (as < this.amin) {
2611      as = this.amin;
2612    }
2613    if (bs > this.bmax) {
2614      bs = this.bmax;
2615    } else if (bs < this.bmin) {
2616      bs = this.bmin;
2617    }
2618    const M = (Ls + 16) / 116;
2619    const L = M + as / 500;
2620    const N = M - bs / 200;
2621    const X = this.XW * this.#fn_g(L);
2622    const Y = this.YW * this.#fn_g(M);
2623    const Z = this.ZW * this.#fn_g(N);
2624    let r, g, b;
2625    if (this.ZW < 1) {
2626      r = X * 3.1339 + Y * -1.617 + Z * -0.4906;
2627      g = X * -0.9785 + Y * 1.916 + Z * 0.0333;
2628      b = X * 0.072 + Y * -0.229 + Z * 1.4057;
2629    } else {
2630      r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
2631      g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
2632      b = X * 0.0557 + Y * -0.204 + Z * 1.057;
2633    }
2634    dest[destOffset] = Math.sqrt(r) * 255;
2635    dest[destOffset + 1] = Math.sqrt(g) * 255;
2636    dest[destOffset + 2] = Math.sqrt(b) * 255;
2637  }
2638  getRgbItem(src, srcOffset, dest, destOffset) {
2639    this.#toRgb(src, srcOffset, false, dest, destOffset);
2640  }
2641  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2642    const maxVal = (1 << bits) - 1;
2643    for (let i = 0; i < count; i++) {
2644      this.#toRgb(src, srcOffset, maxVal, dest, destOffset);
2645      srcOffset += 3;
2646      destOffset += 3 + alpha01;
2647    }
2648  }
2649  getOutputLength(inputLength, alpha01) {
2650    return inputLength * (3 + alpha01) / 3 | 0;
2651  }
2652  isDefaultDecode(decode, bpc) {
2653    return true;
2654  }
2655  get usesZeroToOneRange() {
2656    return shadow(this, "usesZeroToOneRange", false);
2657  }
2658}
2659
2660;// ./src/core/icc_colorspace.js
2661
2662
2663
2664
2665function fetchSync(url) {
2666  const xhr = new XMLHttpRequest();
2667  xhr.open("GET", url, false);
2668  xhr.responseType = "arraybuffer";
2669  xhr.send(null);
2670  return xhr.response;
2671}
2672class IccColorSpace extends ColorSpace {
2673  #transformer;
2674  #convertPixel;
2675  static #useWasm = true;
2676  static #wasmUrl = null;
2677  static #finalizer = null;
2678  constructor(iccProfile, name, numComps) {
2679    if (!IccColorSpace.isUsable) {
2680      throw new Error("No ICC color space support");
2681    }
2682    super(name, numComps);
2683    let inType;
2684    switch (numComps) {
2685      case 1:
2686        inType = DataType.Gray8;
2687        this.#convertPixel = (src, srcOffset, css) => qcms_convert_one(this.#transformer, src[srcOffset] * 255, css);
2688        break;
2689      case 3:
2690        inType = DataType.RGB8;
2691        this.#convertPixel = (src, srcOffset, css) => qcms_convert_three(this.#transformer, src[srcOffset] * 255, src[srcOffset + 1] * 255, src[srcOffset + 2] * 255, css);
2692        break;
2693      case 4:
2694        inType = DataType.CMYK;
2695        this.#convertPixel = (src, srcOffset, css) => qcms_convert_four(this.#transformer, src[srcOffset] * 255, src[srcOffset + 1] * 255, src[srcOffset + 2] * 255, src[srcOffset + 3] * 255, css);
2696        break;
2697      default:
2698        throw new Error(`Unsupported number of components: ${numComps}`);
2699    }
2700    this.#transformer = qcms_transformer_from_memory(iccProfile, inType, Intent.Perceptual);
2701    if (!this.#transformer) {
2702      throw new Error("Failed to create ICC color space");
2703    }
2704    IccColorSpace.#finalizer ||= new FinalizationRegistry(transformer => {
2705      qcms_drop_transformer(transformer);
2706    });
2707    IccColorSpace.#finalizer.register(this, this.#transformer);
2708  }
2709  getRgbHex(src, srcOffset) {
2710    this.#convertPixel(src, srcOffset, true);
2711    return QCMS._cssColor;
2712  }
2713  getRgbItem(src, srcOffset, dest, destOffset) {
2714    QCMS._destBuffer = dest;
2715    QCMS._destOffset = destOffset;
2716    QCMS._destLength = 3;
2717    this.#convertPixel(src, srcOffset, false);
2718    QCMS._destBuffer = null;
2719  }
2720  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2721    src = src.subarray(srcOffset, srcOffset + count * this.numComps);
2722    if (bits !== 8) {
2723      const scale = 255 / ((1 << bits) - 1);
2724      for (let i = 0, ii = src.length; i < ii; i++) {
2725        src[i] *= scale;
2726      }
2727    }
2728    QCMS._mustAddAlpha = alpha01 && dest.buffer === src.buffer;
2729    QCMS._destBuffer = dest;