https://toolminder.com/pdf.worker.mjs

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

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

496function objectSize(obj) {
497  return Object.keys(obj).length;
498}
499function isLittleEndian() {
500  const buffer8 = new Uint8Array(4);
501  buffer8[0] = 1;
502  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
503  return view32[0] === 1;
504}
505class FeatureTest {
506  static get isLittleEndian() {
507    return shadow(this, "isLittleEndian", isLittleEndian());
508  }
509  static get isOffscreenCanvasSupported() {
510    return shadow(this, "isOffscreenCanvasSupported", typeof OffscreenCanvas !== "undefined");
511  }
512  static get isImageDecoderSupported() {
513    return shadow(this, "isImageDecoderSupported", typeof ImageDecoder !== "undefined");
514  }
515  static get isFloat16ArraySupported() {
516    return shadow(this, "isFloat16ArraySupported", typeof Float16Array !== "undefined");
517  }
518  static get isSanitizerSupported() {
519    return shadow(this, "isSanitizerSupported", typeof Sanitizer !== "undefined");
520  }
521  static get platform() {
522    const {
523      platform,
524      userAgent
525    } = navigator;
526    return shadow(this, "platform", {
527      isAndroid: userAgent.includes("Android"),
528      isLinux: platform.includes("Linux"),
529      isMac: platform.includes("Mac"),
530      isWindows: platform.includes("Win"),
531      isFirefox: userAgent.includes("Firefox")
532    });
533  }
534  static get isCSSRoundSupported() {
535    return shadow(this, "isCSSRoundSupported", globalThis.CSS?.supports?.("width: round(1.5px, 1px)"));
536  }
537  static get isAlphaColorInputSupported() {
538    return shadow(this, "isAlphaColorInputSupported", (() => {
539      if (typeof document === "undefined") {
540        return false;
541      }
542      const input = document.createElement("input");
543      input.type = "color";
544      input.setAttribute("alpha", "");
545      input.value = "#ff000080";
546      return input.value !== "#ff0000";
547    })());
548  }
549}
550class Util {
551  static get hexNums() {
552    return shadow(this, "hexNums", Array.from(Array(256).keys(), n => n.toString(16).padStart(2, "0")));
553  }
554  static makeHexColor(r, g, b) {
555    return `#${this.hexNums[r]}${this.hexNums[g]}${this.hexNums[b]}`;
556  }
557  static domMatrixToTransform(dm) {
558    return [dm.a, dm.b, dm.c, dm.d, dm.e, dm.f];
559  }
560  static scaleMinMax(transform, minMax) {
561    let temp;
562    if (transform[0]) {
563      if (transform[0] < 0) {
564        temp = minMax[0];
565        minMax[0] = minMax[2];
566        minMax[2] = temp;
567      }
568      minMax[0] *= transform[0];
569      minMax[2] *= transform[0];
570      if (transform[3] < 0) {
571        temp = minMax[1];
572        minMax[1] = minMax[3];
573        minMax[3] = temp;
574      }
575      minMax[1] *= transform[3];
576      minMax[3] *= transform[3];
577    } else {
578      temp = minMax[0];
579      minMax[0] = minMax[1];
580      minMax[1] = temp;
581      temp = minMax[2];
582      minMax[2] = minMax[3];
583      minMax[3] = temp;
584      if (transform[1] < 0) {
585        temp = minMax[1];
586        minMax[1] = minMax[3];
587        minMax[3] = temp;
588      }
589      minMax[1] *= transform[1];
590      minMax[3] *= transform[1];
591      if (transform[2] < 0) {
592        temp = minMax[0];
593        minMax[0] = minMax[2];
594        minMax[2] = temp;
595      }
596      minMax[0] *= transform[2];
597      minMax[2] *= transform[2];
598    }
599    minMax[0] += transform[4];
600    minMax[1] += transform[5];
601    minMax[2] += transform[4];
602    minMax[3] += transform[5];
603  }
604  static transform(m1, m2) {
605    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]];
606  }
607  static multiplyByDOMMatrix(m, md) {
608    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]];
609  }
610  static applyTransform(p, m, pos = 0) {
611    const p0 = p[pos];
612    const p1 = p[pos + 1];
613    p[pos] = p0 * m[0] + p1 * m[2] + m[4];
614    p[pos + 1] = p0 * m[1] + p1 * m[3] + m[5];
615  }
616  static applyTransformToBezier(p, transform, pos = 0) {
617    const m0 = transform[0];
618    const m1 = transform[1];
619    const m2 = transform[2];
620    const m3 = transform[3];
621    const m4 = transform[4];
622    const m5 = transform[5];
623    for (let i = 0; i < 6; i += 2) {
624      const pI = p[pos + i];
625      const pI1 = p[pos + i + 1];
626      p[pos + i] = pI * m0 + pI1 * m2 + m4;
627      p[pos + i + 1] = pI * m1 + pI1 * m3 + m5;
628    }
629  }
630  static applyInverseTransform(p, m) {
631    const p0 = p[0];
632    const p1 = p[1];
633    const d = m[0] * m[3] - m[1] * m[2];
634    p[0] = (p0 * m[3] - p1 * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
635    p[1] = (-p0 * m[1] + p1 * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
636  }
637  static axialAlignedBoundingBox(rect, transform, output) {
638    const m0 = transform[0];
639    const m1 = transform[1];
640    const m2 = transform[2];
641    const m3 = transform[3];
642    const m4 = transform[4];
643    const m5 = transform[5];
644    const r0 = rect[0];
645    const r1 = rect[1];
646    const r2 = rect[2];
647    const r3 = rect[3];
648    let a0 = m0 * r0 + m4;
649    let a2 = a0;
650    let a1 = m0 * r2 + m4;
651    let a3 = a1;
652    let b0 = m3 * r1 + m5;
653    let b2 = b0;
654    let b1 = m3 * r3 + m5;
655    let b3 = b1;
656    if (m1 !== 0 || m2 !== 0) {
657      const m1r0 = m1 * r0;
658      const m1r2 = m1 * r2;
659      const m2r1 = m2 * r1;
660      const m2r3 = m2 * r3;
661      a0 += m2r1;
662      a3 += m2r1;
663      a1 += m2r3;
664      a2 += m2r3;
665      b0 += m1r0;
666      b3 += m1r0;
667      b1 += m1r2;
668      b2 += m1r2;
669    }
670    output[0] = Math.min(output[0], a0, a1, a2, a3);
671    output[1] = Math.min(output[1], b0, b1, b2, b3);
672    output[2] = Math.max(output[2], a0, a1, a2, a3);
673    output[3] = Math.max(output[3], b0, b1, b2, b3);
674  }
675  static inverseTransform(m) {
676    const d = m[0] * m[3] - m[1] * m[2];
677    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];
678  }
679  static singularValueDecompose2dScale(matrix, output) {
680    const m0 = matrix[0];
681    const m1 = matrix[1];
682    const m2 = matrix[2];
683    const m3 = matrix[3];
684    const a = m0 ** 2 + m1 ** 2;
685    const b = m0 * m2 + m1 * m3;
686    const c = m2 ** 2 + m3 ** 2;
687    const first = (a + c) / 2;
688    const second = Math.sqrt(first ** 2 - (a * c - b ** 2));
689    output[0] = Math.sqrt(first + second || 1);
690    output[1] = Math.sqrt(first - second || 1);
691  }
692  static normalizeRect(rect) {
693    const r = rect.slice(0);
694    if (rect[0] > rect[2]) {
695      r[0] = rect[2];
696      r[2] = rect[0];
697    }
698    if (rect[1] > rect[3]) {
699      r[1] = rect[3];
700      r[3] = rect[1];
701    }
702    return r;
703  }
704  static intersect(rect1, rect2) {
705    const xLow = Math.max(Math.min(rect1[0], rect1[2]), Math.min(rect2[0], rect2[2]));
706    const xHigh = Math.min(Math.max(rect1[0], rect1[2]), Math.max(rect2[0], rect2[2]));
707    if (xLow > xHigh) {
708      return null;
709    }
710    const yLow = Math.max(Math.min(rect1[1], rect1[3]), Math.min(rect2[1], rect2[3]));
711    const yHigh = Math.min(Math.max(rect1[1], rect1[3]), Math.max(rect2[1], rect2[3]));
712    if (yLow > yHigh) {
713      return null;
714    }
715    return [xLow, yLow, xHigh, yHigh];
716  }
717  static pointBoundingBox(x, y, minMax) {
718    minMax[0] = Math.min(minMax[0], x);
719    minMax[1] = Math.min(minMax[1], y);
720    minMax[2] = Math.max(minMax[2], x);
721    minMax[3] = Math.max(minMax[3], y);
722  }
723  static rectBoundingBox(x0, y0, x1, y1, minMax) {
724    minMax[0] = Math.min(minMax[0], x0, x1);
725    minMax[1] = Math.min(minMax[1], y0, y1);
726    minMax[2] = Math.max(minMax[2], x0, x1);
727    minMax[3] = Math.max(minMax[3], y0, y1);
728  }
729  static #getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, t, minMax) {
730    if (t <= 0 || t >= 1) {
731      return;
732    }
733    const mt = 1 - t;
734    const tt = t * t;
735    const ttt = tt * t;
736    const x = mt * (mt * (mt * x0 + 3 * t * x1) + 3 * tt * x2) + ttt * x3;
737    const y = mt * (mt * (mt * y0 + 3 * t * y1) + 3 * tt * y2) + ttt * y3;
738    minMax[0] = Math.min(minMax[0], x);
739    minMax[1] = Math.min(minMax[1], y);
740    minMax[2] = Math.max(minMax[2], x);
741    minMax[3] = Math.max(minMax[3], y);
742  }
743  static #getExtremum(x0, x1, x2, x3, y0, y1, y2, y3, a, b, c, minMax) {
744    if (Math.abs(a) < 1e-12) {
745      if (Math.abs(b) >= 1e-12) {
746        this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, -c / b, minMax);
747      }
748      return;
749    }
750    const delta = b ** 2 - 4 * c * a;
751    if (delta < 0) {
752      return;
753    }
754    const sqrtDelta = Math.sqrt(delta);
755    const a2 = 2 * a;
756    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b + sqrtDelta) / a2, minMax);
757    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b - sqrtDelta) / a2, minMax);
758  }
759  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3, minMax) {
760    minMax[0] = Math.min(minMax[0], x0, x3);
761    minMax[1] = Math.min(minMax[1], y0, y3);
762    minMax[2] = Math.max(minMax[2], x0, x3);
763    minMax[3] = Math.max(minMax[3], y0, y3);
764    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);
765    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);
766  }
767}
768const PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2d8, 0x2c7, 0x2c6, 0x2d9, 0x2dd, 0x2db, 0x2da, 0x2dc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018, 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x141, 0x152, 0x160, 0x178, 0x17d, 0x131, 0x142, 0x153, 0x161, 0x17e, 0, 0x20ac];
769function stringToPDFString(str, keepEscapeSequence = false) {
770  if (str[0] >= "\xEF") {
771    let encoding;
772    if (str[0] === "\xFE" && str[1] === "\xFF") {
773      encoding = "utf-16be";
774      if (str.length % 2 === 1) {
775        str = str.slice(0, -1);
776      }
777    } else if (str[0] === "\xFF" && str[1] === "\xFE") {
778      encoding = "utf-16le";
779      if (str.length % 2 === 1) {
780        str = str.slice(0, -1);
781      }
782    } else if (str[0] === "\xEF" && str[1] === "\xBB" && str[2] === "\xBF") {
783      encoding = "utf-8";
784    }
785    if (encoding) {
786      try {
787        const decoder = new TextDecoder(encoding, {
788          fatal: true
789        });
790        const buffer = stringToBytes(str);
791        const decoded = decoder.decode(buffer);
792        if (keepEscapeSequence || !decoded.includes("\x1b")) {
793          return decoded;
794        }
795        return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
796      } catch (ex) {
797        warn(`stringToPDFString: "${ex}".`);
798      }
799    }
800  }
801  const strBuf = [];
802  for (let i = 0, ii = str.length; i < ii; i++) {
803    const charCode = str.charCodeAt(i);
804    if (!keepEscapeSequence && charCode === 0x1b) {
805      while (++i < ii && str.charCodeAt(i) !== 0x1b) {}
806      continue;
807    }
808    const code = PDFStringTranslateTable[charCode];
809    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
810  }
811  return strBuf.join("");
812}
813function stringToUTF8String(str) {
814  return decodeURIComponent(escape(str));
815}
816function utf8StringToString(str) {
817  return unescape(encodeURIComponent(str));
818}
819function isArrayEqual(arr1, arr2) {
820  if (arr1.length !== arr2.length) {
821    return false;
822  }
823  for (let i = 0, ii = arr1.length; i < ii; i++) {
824    if (arr1[i] !== arr2[i]) {
825      return false;
826    }
827  }
828  return true;
829}
830function getModificationDate(date = new Date()) {
831  if (!(date instanceof Date)) {
832    date = new Date(date);
833  }
834  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")];
835  return buffer.join("");
836}
837let NormalizeRegex = null;
838let NormalizationMap = null;
839function normalizeUnicode(str) {
840  if (!NormalizeRegex) {
841    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;
842    NormalizationMap = new Map([["ſt", "ſt"]]);
843  }
844  return str.replaceAll(NormalizeRegex, (_, p1, p2) => p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2));
845}
846function getUuid() {
847  if (typeof crypto.randomUUID === "function") {
848    return crypto.randomUUID();
849  }
850  const buf = new Uint8Array(32);
851  crypto.getRandomValues(buf);
852  return bytesToString(buf);
853}
854const AnnotationPrefix = "pdfjs_internal_id_";
855function _isValidExplicitDest(validRef, validName, dest) {
856  if (!Array.isArray(dest) || dest.length < 2) {
857    return false;
858  }
859  const [page, zoom, ...args] = dest;
860  if (!validRef(page) && !Number.isInteger(page)) {
861    return false;
862  }
863  if (!validName(zoom)) {
864    return false;
865  }
866  const argsLen = args.length;
867  let allowNull = true;
868  switch (zoom.name) {
869    case "XYZ":
870      if (argsLen < 2 || argsLen > 3) {
871        return false;
872      }
873      break;
874    case "Fit":
875    case "FitB":
876      return argsLen === 0;
877    case "FitH":
878    case "FitBH":
879    case "FitV":
880    case "FitBV":
881      if (argsLen > 1) {
882        return false;
883      }
884      break;
885    case "FitR":
886      if (argsLen !== 4) {
887        return false;
888      }
889      allowNull = false;
890      break;
891    default:
892      return false;
893  }
894  for (const arg of args) {
895    if (typeof arg === "number" || allowNull && arg === null) {
896      continue;
897    }
898    return false;
899  }
900  return true;
901}
902const makeArr = () => [];
903const makeMap = () => new Map();
904const makeObj = () => Object.create(null);
905
906;// ./src/core/primitives.js
907
908const CIRCULAR_REF = Symbol("CIRCULAR_REF");
909const EOF = Symbol("EOF");
910let CmdCache = Object.create(null);
911let NameCache = Object.create(null);
912let RefCache = Object.create(null);
913function clearPrimitiveCaches() {
914  CmdCache = Object.create(null);
915  NameCache = Object.create(null);
916  RefCache = Object.create(null);
917}
918class Name {
919  constructor(name) {
920    this.name = name;
921  }
922  static get(name) {
923    return NameCache[name] ||= new Name(name);
924  }
925}
926class Cmd {
927  constructor(cmd) {
928    this.cmd = cmd;
929  }
930  static get(cmd) {
931    return CmdCache[cmd] ||= new Cmd(cmd);
932  }
933}
934const nonSerializable = function nonSerializableClosure() {
935  return nonSerializable;
936};
937class Dict {
938  __nonSerializable__ = nonSerializable;
939  #map = new Map();
940  objId = null;
941  suppressEncryption = false;

1119    const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
1120    return RefCache[key] ||= new Ref(num, gen);
1121  }
1122}
1123class RefSet {
1124  constructor(parent = null) {
1125    this._set = new Set(parent?._set);
1126  }
1127  has(ref) {
1128    return this._set.has(ref.toString());
1129  }
1130  put(ref) {
1131    this._set.add(ref.toString());
1132  }
1133  remove(ref) {
1134    this._set.delete(ref.toString());
1135  }
1136  [Symbol.iterator]() {
1137    return this._set.values();
1138  }
1139  clear() {
1140    this._set.clear();
1141  }
1142}
1143class RefSetCache {
1144  _map = new Map();
1145  get size() {
1146    return this._map.size;
1147  }
1148  get(ref) {
1149    return this._map.get(ref.toString());
1150  }
1151  has(ref) {
1152    return this._map.has(ref.toString());
1153  }
1154  put(ref, obj) {
1155    this._map.set(ref.toString(), obj);
1156  }
1157  putAlias(ref, aliasRef) {
1158    this._map.set(ref.toString(), this.get(aliasRef));
1159  }
1160  [Symbol.iterator]() {
1161    return this._map.values();
1162  }
1163  clear() {
1164    this._map.clear();
1165  }
1166  *values() {
1167    yield* this._map.values();
1168  }
1169  *items() {
1170    for (const [ref, value] of this._map) {
1171      yield [Ref.fromString(ref), value];
1172    }
1173  }
1174  *keys() {
1175    for (const ref of this._map.keys()) {
1176      yield Ref.fromString(ref);
1177    }
1178  }
1179}
1180function isName(v, name) {
1181  return v instanceof Name && (name === undefined || v.name === name);
1182}
1183function isCmd(v, cmd) {
1184  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
1185}
1186function isDict(v, type) {
1187  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
1188}
1189function isRefsEqual(v1, v2) {
1190  return v1.num === v2.num && v1.gen === v2.gen;
1191}
1192
1193;// ./src/core/base_stream.js
1194
1195class BaseStream {
1196  get length() {
1197    unreachable("Abstract getter `length` accessed");
1198  }
1199  get isEmpty() {
1200    unreachable("Abstract getter `isEmpty` accessed");
1201  }
1202  get isDataLoaded() {
1203    return shadow(this, "isDataLoaded", true);
1204  }
1205  getByte() {
1206    unreachable("Abstract method `getByte` called");
1207  }
1208  getBytes(length) {
1209    unreachable("Abstract method `getBytes` called");
1210  }
1211  async getImageData(length, decoderOptions) {
1212    return this.getBytes(length, decoderOptions);
1213  }
1214  async asyncGetBytes() {
1215    unreachable("Abstract method `asyncGetBytes` called");
1216  }
1217  get isAsync() {
1218    return false;
1219  }
1220  get isAsyncDecoder() {
1221    return false;
1222  }
1223  get isImageStream() {
1224    return false;
1225  }
1226  get canAsyncDecodeImageFromBuffer() {
1227    return false;
1228  }
1229  async getTransferableImage() {
1230    return null;
1231  }
1232  peekByte() {
1233    const peekedByte = this.getByte();
1234    if (peekedByte !== -1) {
1235      this.pos--;
1236    }
1237    return peekedByte;
1238  }
1239  peekBytes(length) {
1240    const bytes = this.getBytes(length);
1241    this.pos -= bytes.length;
1242    return bytes;
1243  }
1244  getUint16() {
1245    const b0 = this.getByte();
1246    const b1 = this.getByte();
1247    if (b0 === -1 || b1 === -1) {
1248      return -1;
1249    }
1250    return (b0 << 8) + b1;
1251  }
1252  getInt32() {
1253    const b0 = this.getByte();
1254    const b1 = this.getByte();
1255    const b2 = this.getByte();
1256    const b3 = this.getByte();
1257    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1258  }
1259  getByteRange(begin, end) {
1260    unreachable("Abstract method `getByteRange` called");
1261  }
1262  getString(length) {
1263    return bytesToString(this.getBytes(length));
1264  }
1265  skip(n) {
1266    this.pos += n || 1;
1267  }
1268  reset() {
1269    unreachable("Abstract method `reset` called");
1270  }
1271  moveStart() {
1272    unreachable("Abstract method `moveStart` called");
1273  }
1274  makeSubStream(start, length, dict = null) {
1275    unreachable("Abstract method `makeSubStream` called");
1276  }
1277  getBaseStreams() {
1278    return null;
1279  }
1280  getOriginalStream() {
1281    return this.stream?.getOriginalStream() || this;
1282  }
1283}
1284
1285;// ./src/core/core_utils.js
1286
1287
1288
1289const PDF_VERSION_REGEXP = /^[1-9]\.\d$/;
1290const MAX_INT_32 = 2 ** 31 - 1;
1291const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
1292const RESOURCES_KEYS_OPERATOR_LIST = ["ColorSpace", "ExtGState", "Font", "Pattern", "Properties", "Shading", "XObject"];
1293const RESOURCES_KEYS_TEXT_CONTENT = ["ExtGState", "Font", "Properties", "XObject"];
1294function getLookupTableFactory(initializer) {
1295  let lookup;
1296  return function () {
1297    if (initializer) {
1298      lookup = Object.create(null);
1299      initializer(lookup);
1300      initializer = null;
1301    }
1302    return lookup;
1303  };
1304}
1305class MissingDataException extends BaseException {
1306  constructor(begin, end) {
1307    super(`Missing data [${begin}, ${end})`, "MissingDataException");
1308    this.begin = begin;
1309    this.end = end;
1310  }
1311}
1312class ParserEOFException extends BaseException {
1313  constructor(msg) {
1314    super(msg, "ParserEOFException");
1315  }
1316}
1317class XRefEntryException extends BaseException {
1318  constructor(msg) {

1319    super(msg, "XRefEntryException");
1320  }
1321}
1322class XRefParseException extends BaseException {
1323  constructor(msg) {
1324    super(msg, "XRefParseException");
1325  }
1326}
1327function arrayBuffersToBytes(arr) {
1328  const length = arr.length;
1329  if (length === 0) {
1330    return new Uint8Array(0);
1331  }
1332  if (length === 1) {
1333    return new Uint8Array(arr[0]);
1334  }
1335  let dataLength = 0;
1336  for (let i = 0; i < length; i++) {
1337    dataLength += arr[i].byteLength;
1338  }
1339  const data = new Uint8Array(dataLength);
1340  let pos = 0;
1341  for (let i = 0; i < length; i++) {
1342    const item = new Uint8Array(arr[i]);
1343    data.set(item, pos);
1344    pos += item.byteLength;
1345  }
1346  return data;
1347}
1348async function fetchBinaryData(url) {
1349  const response = await fetch(url);
1350  if (!response.ok) {
1351    throw new Error(`Failed to fetch file "${url}" with "${response.statusText}".`);
1352  }
1353  return response.bytes();
1354}
1355function getInheritableProperty({
1356  dict,
1357  key,
1358  getArray = false,
1359  stopWhenFound = true
1360}) {
1361  let values;
1362  const visited = new RefSet();
1363  while (dict instanceof Dict && !(dict.objId && visited.has(dict.objId))) {
1364    if (dict.objId) {
1365      visited.put(dict.objId);
1366    }
1367    const value = getArray ? dict.getArray(key) : dict.get(key);
1368    if (value !== undefined) {
1369      if (stopWhenFound) {
1370        return value;
1371      }
1372      (values ||= []).push(value);
1373    }
1374    dict = dict.get("Parent");
1375  }
1376  return values;
1377}
1378function getParentToUpdate(dict, ref, xref) {
1379  const visited = new RefSet();
1380  const firstDict = dict;
1381  const result = {
1382    dict: null,
1383    ref: null
1384  };
1385  while (dict instanceof Dict && !visited.has(ref)) {
1386    visited.put(ref);
1387    if (dict.has("T")) {
1388      break;
1389    }
1390    ref = dict.getRaw("Parent");
1391    if (!(ref instanceof Ref)) {
1392      return result;
1393    }
1394    dict = xref.fetch(ref);
1395  }
1396  if (dict instanceof Dict && dict !== firstDict) {
1397    result.dict = dict;
1398    result.ref = ref;
1399  }
1400  return result;
1401}
1402function deepCompare(a, b) {
1403  if (a === b) {
1404    return true;
1405  }
1406  if (a instanceof Dict && b instanceof Dict) {
1407    if (a.size !== b.size) {
1408      return false;
1409    }
1410    for (const [key, value1] of a.getRawEntries()) {
1411      const value2 = b.getRaw(key);
1412      if (value2 === undefined || !deepCompare(value1, value2)) {
1413        return false;
1414      }
1415    }
1416    return true;
1417  }
1418  if (Array.isArray(a) && Array.isArray(b)) {
1419    if (a.length !== b.length) {
1420      return false;
1421    }
1422    for (let i = 0, ii = a.length; i < ii; i++) {
1423      if (!deepCompare(a[i], b[i])) {
1424        return false;
1425      }
1426    }
1427    return true;
1428  }
1429  return false;
1430}
1431const 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"];
1432function toRomanNumerals(number, lowerCase = false) {
1433  assert(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
1434  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];
1435  return lowerCase ? roman.toLowerCase() : roman;
1436}
1437function isWhiteSpace(ch) {
1438  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
1439}
1440function isBooleanArray(arr, len) {
1441  return Array.isArray(arr) && (len === null || arr.length === len) && arr.every(x => typeof x === "boolean");
1442}
1443function isNumberArray(arr, len) {
1444  if (Array.isArray(arr)) {
1445    return (len === null || arr.length === len) && arr.every(x => typeof x === "number");
1446  }
1447  return ArrayBuffer.isView(arr) && !(arr instanceof BigInt64Array || arr instanceof BigUint64Array) && (len === null || arr.length === len);
1448}
1449function lookupMatrix(arr, fallback) {
1450  return isNumberArray(arr, 6) ? arr : fallback;
1451}
1452function lookupRect(arr, fallback) {
1453  return isNumberArray(arr, 4) ? arr : fallback;
1454}
1455function lookupNormalRect(arr, fallback) {
1456  return isNumberArray(arr, 4) ? Util.normalizeRect(arr) : fallback;
1457}
1458function parseXFAPath(path) {
1459  const positionPattern = /(.+)\[(\d+)\]$/;
1460  return path.split(".").map(component => {
1461    const m = component.match(positionPattern);
1462    if (m) {
1463      return {
1464        name: m[1],
1465        pos: parseInt(m[2], 10)
1466      };
1467    }
1468    return {
1469      name: component,
1470      pos: 0
1471    };
1472  });
1473}
1474function escapePDFName(str) {
1475  const buffer = [];
1476  let start = 0;
1477  for (let i = 0, ii = str.length; i < ii; i++) {
1478    const char = str.charCodeAt(i);
1479    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) {
1480      if (start < i) {
1481        buffer.push(str.substring(start, i));
1482      }
1483      buffer.push(`#${char.toString(16)}`);
1484      start = i + 1;
1485    }
1486  }
1487  if (buffer.length === 0) {
1488    return str;
1489  }
1490  if (start < str.length) {
1491    buffer.push(str.substring(start, str.length));
1492  }
1493  return buffer.join("");
1494}
1495function escapeString(str) {
1496  return str.replaceAll(/([()\\\n\r])/g, match => {
1497    if (match === "\n") {
1498      return "\\n";
1499    } else if (match === "\r") {
1500      return "\\r";
1501    }
1502    return `\\${match}`;
1503  });
1504}
1505function _collectJS(entry, xref, list, parents) {
1506  if (!entry) {
1507    return;
1508  }
1509  let parent = null;
1510  if (entry instanceof Ref) {
1511    if (parents.has(entry)) {
1512      return;
1513    }
1514    parent = entry;
1515    parents.put(parent);
1516    entry = xref.fetch(entry);
1517  }
1518  if (Array.isArray(entry)) {
1519    for (const element of entry) {
1520      _collectJS(element, xref, list, parents);
1521    }
1522  } else if (entry instanceof Dict) {
1523    if (isName(entry.get("S"), "JavaScript")) {
1524      const js = entry.get("JS");
1525      let code;
1526      if (js instanceof BaseStream) {
1527        code = js.getString();
1528      } else if (typeof js === "string") {
1529        code = js;
1530      }
1531      code &&= stringToPDFString(code, true).replaceAll("\x00", "");
1532      if (code) {
1533        list.push(code.trim());
1534      }
1535    }
1536    _collectJS(entry.getRaw("Next"), xref, list, parents);
1537  }
1538  if (parent) {
1539    parents.remove(parent);
1540  }
1541}
1542function collectActions(xref, dict, eventType) {
1543  const actions = Object.create(null);
1544  const additionalActionsDicts = getInheritableProperty({
1545    dict,
1546    key: "AA",
1547    stopWhenFound: false
1548  });
1549  if (additionalActionsDicts) {
1550    for (let i = additionalActionsDicts.length - 1; i >= 0; i--) {
1551      const additionalActions = additionalActionsDicts[i];
1552      if (!(additionalActions instanceof Dict)) {
1553        continue;
1554      }
1555      for (const [key, rawActionDict] of additionalActions.getRawEntries()) {
1556        const action = eventType[key];
1557        if (!action) {
1558          continue;
1559        }
1560        const parents = new RefSet();
1561        const list = [];
1562        _collectJS(rawActionDict, xref, list, parents);
1563        if (list.length > 0) {
1564          actions[action] = list;
1565        }
1566      }
1567    }
1568  }
1569  if (dict.has("A")) {
1570    const actionDict = dict.get("A");
1571    const parents = new RefSet();
1572    const list = [];
1573    _collectJS(actionDict, xref, list, parents);
1574    if (list.length > 0) {
1575      actions.Action = list;
1576    }
1577  }
1578  return objectSize(actions) > 0 ? actions : null;
1579}
1580const XMLEntities = {
1581  0x3c: "&lt;",
1582  0x3e: "&gt;",
1583  0x26: "&amp;",
1584  0x22: "&quot;",
1585  0x27: "&apos;"
1586};
1587function* codePointIter(str) {
1588  for (let i = 0, ii = str.length; i < ii; i++) {
1589    const char = str.codePointAt(i);
1590    if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1591      i++;
1592    }
1593    yield char;
1594  }
1595}
1596function encodeToXmlString(str) {
1597  const buffer = [];
1598  let start = 0;
1599  for (let i = 0, ii = str.length; i < ii; i++) {
1600    const char = str.codePointAt(i);
1601    if (0x20 <= char && char <= 0x7e) {
1602      const entity = XMLEntities[char];
1603      if (entity) {
1604        if (start < i) {
1605          buffer.push(str.substring(start, i));
1606        }
1607        buffer.push(entity);
1608        start = i + 1;
1609      }
1610    } else {
1611      if (start < i) {
1612        buffer.push(str.substring(start, i));
1613      }
1614      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
1615      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1616        i++;
1617      }
1618      start = i + 1;
1619    }
1620  }
1621  if (buffer.length === 0) {
1622    return str;
1623  }
1624  if (start < str.length) {
1625    buffer.push(str.substring(start, str.length));
1626  }
1627  return buffer.join("");
1628}
1629function validateFontName(fontFamily, mustWarn = false) {
1630  const m = /^("|').*("|')$/.exec(fontFamily);
1631  if (m && m[1] === m[2]) {
1632    const re = new RegExp(`[^\\\\]${m[1]}`);
1633    if (re.test(fontFamily.slice(1, -1))) {
1634      if (mustWarn) {
1635        warn(`FontFamily contains unescaped ${m[1]}: ${fontFamily}.`);
1636      }
1637      return false;

1638    }
1639  } else {
1640    for (const ident of fontFamily.split(/[ \t]+/)) {
1641      if (/^(\d|(-(\d|-)))/.test(ident) || !/^[\w-\\]+$/.test(ident)) {
1642        if (mustWarn) {
1643          warn(`FontFamily contains invalid <custom-ident>: ${fontFamily}.`);
1644        }
1645        return false;
1646      }
1647    }
1648  }
1649  return true;
1650}
1651function validateCSSFont(cssFontInfo) {
1652  const DEFAULT_CSS_FONT_OBLIQUE = "14";
1653  const DEFAULT_CSS_FONT_WEIGHT = "400";
1654  const CSS_FONT_WEIGHT_VALUES = new Set(["100", "200", "300", "400", "500", "600", "700", "800", "900", "1000", "normal", "bold", "bolder", "lighter"]);
1655  const {
1656    fontFamily,
1657    fontWeight,
1658    italicAngle
1659  } = cssFontInfo;
1660  if (!validateFontName(fontFamily, true)) {
1661    return false;
1662  }
1663  const weight = fontWeight ? fontWeight.toString() : "";
1664  cssFontInfo.fontWeight = CSS_FONT_WEIGHT_VALUES.has(weight) ? weight : DEFAULT_CSS_FONT_WEIGHT;
1665  const angle = parseFloat(italicAngle);
1666  cssFontInfo.italicAngle = isNaN(angle) || angle < -90 || angle > 90 ? DEFAULT_CSS_FONT_OBLIQUE : italicAngle.toString();
1667  return true;
1668}
1669function recoverJsURL(str) {
1670  const URL_OPEN_METHODS = ["app.launchURL", "window.open", "xfa.host.gotoURL"];
1671  const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").replaceAll(".", "\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
1672  const jsUrl = regex.exec(str);
1673  if (jsUrl?.[2]) {
1674    return {
1675      url: jsUrl[2],
1676      newWindow: jsUrl[1] === "app.launchURL" && jsUrl[3] === "true"
1677    };
1678  }
1679  return null;
1680}
1681function numberToString(value) {
1682  if (Number.isInteger(value)) {
1683    return value.toString();
1684  }
1685  const roundedValue = Math.round(value * 100);
1686  if (roundedValue % 100 === 0) {
1687    return (roundedValue / 100).toString();
1688  }
1689  if (roundedValue % 10 === 0) {
1690    return value.toFixed(1);
1691  }
1692  return value.toFixed(2);
1693}
1694function getNewAnnotationsMap(annotationStorage) {
1695  if (!annotationStorage) {
1696    return null;
1697  }
1698  const newAnnotationsByPage = new Map();
1699  for (const [key, value] of annotationStorage) {
1700    if (!key.startsWith(AnnotationEditorPrefix)) {
1701      continue;
1702    }
1703    newAnnotationsByPage.getOrInsertComputed(value.pageIndex, makeArr).push(value);
1704  }
1705  return newAnnotationsByPage.size > 0 ? newAnnotationsByPage : null;
1706}
1707function stringToAsciiOrUTF16BE(str) {
1708  if (str === null || str === undefined) {
1709    return str;
1710  }
1711  return isAscii(str) ? str : stringToUTF16String(str, true);
1712}
1713function isAscii(str) {
1714  if (typeof str !== "string") {
1715    return false;
1716  }
1717  return !str || /^[\x00-\x7F]*$/.test(str);
1718}
1719function stringToUTF16HexString(str) {
1720  const buf = [];
1721  for (let i = 0, ii = str.length; i < ii; i++) {
1722    const char = str.charCodeAt(i);
1723    buf.push(Util.hexNums[char >> 8 & 0xff], Util.hexNums[char & 0xff]);
1724  }
1725  return buf.join("");
1726}
1727function stringToUTF16String(str, bigEndian = false) {
1728  const buf = [];
1729  if (bigEndian) {
1730    buf.push("\xFE\xFF");
1731  }
1732  for (let i = 0, ii = str.length; i < ii; i++) {
1733    const char = str.charCodeAt(i);
1734    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1735  }
1736  return buf.join("");
1737}
1738function getRotationMatrix(rotation, width, height) {
1739  switch (rotation) {
1740    case 90:
1741      return [0, 1, -1, 0, width, 0];
1742    case 180:
1743      return [-1, 0, 0, -1, width, height];
1744    case 270:
1745      return [0, -1, 1, 0, 0, height];
1746    default:
1747      throw new Error("Invalid rotation");
1748  }
1749}
1750function getSizeInBytes(x) {
1751  return Math.ceil(Math.ceil(Math.log2(1 + x)) / 8);
1752}
1753
1754;// ./external/qcms/qcms_utils.js
1755class QCMS {
1756  static #memoryArray = null;
1757  static _memory = null;
1758  static _mustAddAlpha = false;
1759  static _destBuffer = null;
1760  static _destOffset = 0;
1761  static _destLength = 0;
1762  static _cssColor = "";
1763  static _makeHexColor = null;
1764  static get _memoryArray() {
1765    const array = this.#memoryArray;
1766    if (array?.byteLength) {
1767      return array;
1768    }
1769    return this.#memoryArray = new Uint8Array(this._memory.buffer);
1770  }
1771}
1772function copy_result(ptr, len) {
1773  const {
1774    _mustAddAlpha,
1775    _destBuffer,
1776    _destOffset,
1777    _destLength,
1778    _memoryArray
1779  } = QCMS;
1780  if (len === _destLength) {
1781    _destBuffer.set(_memoryArray.subarray(ptr, ptr + len), _destOff

1933
1934  wasm = instance.exports;
1935  wasmModule = module;
1936  cachedUint8ArrayMemory0 = null;
1937  wasm.__wbindgen_start();
1938  return wasm;
1939}
1940async function __wbg_load(module, imports) {
1941  if (typeof Response === 'function' && module instanceof Response) {
1942    if (typeof WebAssembly.instantiateStreaming === 'function') {
1943      try {
1944        return await WebAssembly.instantiateStreaming(module, imports);
1945      } catch (e) {
1946        const validResponse = module.ok && expectedResponseType(module.type);
1947        if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
1948          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);
1949        } else {
1950          throw e;
1951        }
1952      }
1953    }
1954    const bytes = await module.arrayBuffer();
1955    return await WebAssembly.instantiate(bytes, imports);
1956  } else {
1957    const instance = await WebAssembly.instantiate(module, imports);
1958    if (instance instanceof WebAssembly.Instance) {
1959      return {
1960        instance,
1961        module
1962      };
1963    } else {
1964      return instance;
1965    }
1966  }
1967  function expectedResponseType(type) {
1968    switch (type) {
1969      case 'basic':
1970      case 'cors':
1971      case 'default':
1972        return true;
1973    }
1974    return false;
1975  }
1976}
1977function initSync(module) {
1978  if (wasm !== undefined) return wasm;
1979  if (module !== undefined) {
1980    if (Object.getPrototypeOf(module) === Object.prototype) {
1981      ({
1982        module
1983      } = module);
1984    } else {
1985      console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
1986    }
1987  }
1988  const imports = __wbg_get_imports();
1989  if (!(module instanceof WebAssembly.Module)) {
1990    module = new WebAssembly.Module(module);
1991  }
1992  const instance = new WebAssembly.Instance(module, imports);
1993  return __wbg_finalize_init(instance, module);
1994}
1995async function __wbg_init(module_or_path) {
1996  if (wasm !== undefined) return wasm;
1997  if (module_or_path !== undefined) {
1998    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
1999      ({
2000        module_or_path
2001      } = module_or_path);
2002    } else {
2003      console.warn('using deprecated parameters for the initialization function; pass a single object instead');
2004    }
2005  }
2006  const imports = __wbg_get_imports();
2007  if (typeof module_or_path === 'string' || typeof Request === 'function' && module_or_path instanceof Request || typeof URL === 'function' && module_or_path instanceof URL) {
2008    module_or_path = fetch(module_or_path);
2009  }
2010  const {
2011    instance,
2012    module
2013  } = await __wbg_load(await module_or_path, imports);
2014  return __wbg_finalize_init(instance, module);
2015}
2016
2017;// ./src/shared/math_clamp.js
2018function MathClamp(v, min, max) {
2019  return Math.min(Math.max(v, min), max);
2020}
2021
2022;// ./src/core/colorspace.js
2023
2024
2025
2026function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
2027  const COMPONENTS = 3;
2028  alpha01 = alpha01 !== 1 ? 0 : alpha01;
2029  const xRatio = w1 / w2;
2030  const yRatio = h1 / h2;
2031  let newIndex = 0,
2032    oldIndex;
2033  const xScaled = new Uint16Array(w2);
2034  const w1Scanline = w1 * COMPONENTS;
2035  for (let i = 0; i < w2; i++) {
2036    xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
2037  }
2038  for (let i = 0; i < h2; i++) {
2039    const py = Math.floor(i * yRatio) * w1Scanline;
2040    for (let j = 0; j < w2; j++) {
2041      oldIndex = py + xScaled[j];
2042      dest[newIndex++] = src[oldIndex++];
2043      dest[newIndex++] = src[oldIndex++];
2044      dest[newIndex++] = src[oldIndex++];
2045      newIndex += alpha01;
2046    }
2047  }
2048}
2049function resizeRgbaImage(src, dest, w1, h1, w2, h2, alpha01) {
2050  const xRatio = w1 / w2;
2051  const yRatio = h1 / h2;
2052  let newIndex = 0;
2053  const xScaled = new Uint16Array(w2);
2054  if (alpha01 === 1) {
2055    for (let i = 0; i < w2; i++) {
2056      xScaled[i] = Math.floor(i * xRatio);
2057    }
2058    const src32 = new Uint32Array(src.buffer);
2059    const dest32 = new Uint32Array(dest.buffer);
2060    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2061    for (let i = 0; i < h2; i++) {
2062      const buf = src32.subarray(Math.floor(i * yRatio) * w1);
2063      for (let j = 0; j < w2; j++) {
2064        dest32[newIndex++] |= buf[xScaled[j]] & rgbMask;
2065      }
2066    }
2067  } else {
2068    const COMPONENTS = 4;
2069    const w1Scanline = w1 * COMPONENTS;
2070    for (let i = 0; i < w2; i++) {
2071      xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
2072    }
2073    for (let i = 0; i < h2; i++) {
2074      const buf = src.subarray(Math.floor(i * yRatio) * w1Scanline);
2075      for (let j = 0; j < w2; j++) {
2076        const oldIndex = xScaled[j];
2077        dest[newIndex++] = buf[oldIndex];
2078        dest[newIndex++] = buf[oldIndex + 1];
2079        dest[newIndex++] = buf[oldIndex + 2];
2080      }
2081    }
2082  }
2083}
2084function copyRgbaImage(src, dest, alpha01) {
2085  if (alpha01 === 1) {
2086    const src32 = new Uint32Array(src.buffer);
2087    const dest32 = new Uint32Array(dest.buffer);
2088    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2089    for (let i = 0, ii = src32.length; i < ii; i++) {
2090      dest32[i] |= src32[i] & rgbMask;
2091    }
2092  } else {
2093    let j = 0;
2094    for (let i = 0, ii = src.length; i < ii; i += 4) {
2095      dest[j++] = src[i];
2096      dest[j++] = src[i + 1];
2097      dest[j++] = src[i + 2];
2098    }
2099  }
2100}
2101function isDefaultDecodeHelper(decode, expectedLen) {
2102  if (!Array.isArray(decode)) {
2103    return true;
2104  }
2105  const decodeLen = decode.length;
2106  if (decodeLen < expectedLen) {
2107    warn("Decode map length is too short.");
2108    return true;
2109  }
2110  if (decodeLen > expectedLen) {
2111    info("Truncating too long decode map.");
2112    decode.length = expectedLen;
2113  }
2114  return false;
2115}
2116class ColorSpace {
2117  static #rgbBuf = new Uint8ClampedArray(3);
2118  constructor(name, numComps) {
2119    this.name = name;
2120    this.numComps = numComps;
2121  }
2122  getRgb(src, srcOffset, output = new Uint8ClampedArray(3)) {
2123    this.getRgbItem(src, srcOffset, output, 0);
2124    return output;
2125  }
2126  getRgbHex(src, srcOffset) {
2127    const buffer = this.getRgb(src, srcOffset, ColorSpace.#rgbBuf);
2128    return Util.makeHexColor(buffer[0], buffer[1], buffer[2]);
2129  }
2130  getRgbItem(src, srcOffset, dest, destOffset) {
2131    unreachable("Should not call ColorSpace.getRgbItem");
2132  }
2133  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2134    unreachable("Should not call ColorSpace.getRgbBuffer");
2135  }
2136  get

2136OutputLength(inputLength, alpha01) {
2137    unreachable("Should not call ColorSpace.getOutputLength");
2138  }
2139  isPassthrough(bits) {
2140    return false;
2141  }
2142  isDefaultDecode(decode, bpc) {
2143    return ColorSpace.isDefaultDecode(decode, this.numComps);
2144  }
2145  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2146    const count = originalWidth * originalHeight;
2147    let rgbBuf = null;
2148    const numComponentColors = 1 << bpc;
2149    const needsResizing = originalHeight !== height || originalWidth !== width;
2150    if (this.isPassthrough(bpc)) {
2151      rgbBuf = comps;
2152    } else if (this.numComps === 1 && count > numComponentColors && this.name !== "DeviceGray" && this.name !== "DeviceRGB") {
2153      const allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : new Uint16Array(numComponentColors);
2154      for (let i = 0; i < numComponentColors; i++) {
2155        allColors[i] = i;
2156      }
2157      const colorMap = new Uint8ClampedArray(numComponentColors * 3);
2158      this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc, 0);
2159      if (!needsResizing) {
2160        let destPos = 0;
2161        for (let i = 0; i < count; ++i) {
2162          const key = comps[i] * 3;
2163          dest[destPos++] = colorMap[key];
2164          dest[destPos++] = colorMap[key + 1];
2165          dest[destPos++] = colorMap[key + 2];
2166          destPos += alpha01;
2167        }
2168      } else {
2169        rgbBuf = new Uint8Array(count * 3);
2170        let rgbPos = 0;
2171        for (let i = 0; i < count; ++i) {
2172          const key = comps[i] * 3;
2173          rgbBuf[rgbPos++] = colorMap[key];
2174          rgbBuf[rgbPos++] = colorMap[key + 1];
2175          rgbBuf[rgbPos++] = colorMap[key + 2];
2176        }
2177      }
2178    } else if (!needsResizing) {
2179      this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, alpha01);
2180    } else {
2181      rgbBuf = new Uint8ClampedArray(count * 3);
2182      this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, 0);
2183    }
2184    if (rgbBuf) {
2185      if (needsResizing) {
2186        resizeRgbImage(rgbBuf, dest, originalWidth, originalHeight, width, height, alpha01);
2187      } else {
2188        let destPos = 0,
2189          rgbPos = 0;
2190        for (let i = 0, ii = width * actualHeight; i < ii; i++) {
2191          dest[destPos++] = rgbBuf[rgbPos++];
2192          dest[destPos++] = rgbBuf[rgbPos++];
2193          dest[destPos++] = rgbBuf[rgbPos++];
2194          destPos += alpha01;
2195        }
2196      }
2197    }
2198  }
2199  get usesZeroToOneRange() {
2200    return shadow(this, "usesZeroToOneRange", true);
2201  }
2202  static isDefaultDecode(decode, numComps) {
2203    if (isDefaultDecodeHelper(decode, numComps * 2)) {
2204      return true;
2205    }
2206    for (let i = 0, ii = decode.length; i < ii; i += 2) {
2207      if (decode[i] !== 0 || decode[i + 1] !== 1) {
2208        return false;
2209      }
2210    }
2211    return true;
2212  }
2213}
2214class AlternateCS extends ColorSpace {
2215  constructor(numComps, base, tintFn) {
2216    super("Alternate", numComps);
2217    this.base = base;
2218    this.tintFn = tintFn;
2219    this.tmpBuf = new Float32Array(base.numComps);
2220  }
2221  getRgbItem(src, srcOffset, dest, destOffset) {
2222    const tmpBuf = this.tmpBuf;
2223    this.tintFn(src, srcOffset, tmpBuf, 0);
2224    this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
2225  }
2226  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2227    const tintFn = this.tintFn;
2228    const base = this.base;
2229    const scale = 1 / ((1 << bits) - 1);
2230    const baseNumComps = base.numComps;
2231    const usesZeroToOneRange = base.usesZeroToOneRange;
2232    const isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) && alpha01 === 0;

2233    let pos = isPassthrough ? destOffset : 0;
2234    const baseBuf = isPassthrough ? dest : new Uint8ClampedArray(baseNumComps * count);
2235    const numComps = this.numComps;
2236    const scaled = new Float32Array(numComps);
2237    const tinted = new Float32Array(baseNumComps);
2238    let i, j;
2239    for (i = 0; i < count; i++) {
2240      for (j = 0; j < numComps; j++) {
2241        scaled[j] = src[srcOffset++] * scale;
2242      }
2243      tintFn(scaled, 0, tinted, 0);
2244      if (usesZeroToOneRange) {
2245        for (j = 0; j < baseNumComps; j++) {
2246          baseBuf[pos++] = tinted[j] * 255;
2247        }
2248      } else {
2249        base.getRgbItem(tinted, 0, baseBuf, pos);
2250        pos += baseNumComps;
2251      }
2252    }
2253    if (!isPassthrough) {
2254      base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);
2255    }
2256  }
2257  getOutputLength(inputLength, alpha01) {
2258    return this.base.getOutputLength(inputLength * this.base.numComps / this.numComps, alpha01);
2259  }
2260}
2261class PatternCS extends ColorSpace {
2262  constructor(baseCS) {
2263    super("Pattern", null);
2264    this.base = baseCS;
2265  }
2266  isDefaultDecode(decode, bpc) {
2267    unreachable("Should not call PatternCS.isDefaultDecode");
2268  }
2269}
2270class IndexedCS extends ColorSpace {
2271  constructor(base, highVal, lookup) {
2272    super("Indexed", 1);
2273    this.base = base;
2274    this.highVal = highVal;
2275    const length = base.numComps * (highVal + 1);
2276    this.lookup = new Uint8Array(length);
2277    if (lookup instanceof BaseStream) {
2278      const bytes = lookup.getBytes(length);
2279      this.lookup.set(bytes);
2280    } else if (typeof lookup === "string") {
2281      for (let i = 0; i < length; ++i) {
2282        this.lookup[i] = lookup.charCodeAt(i) & 0xff;
2283      }
2284    } else {
2285      throw new FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);
2286    }
2287  }
2288  getRgbItem(src, srcOffset, dest, destOffset) {
2289    const {
2290      base,
2291      highVal,
2292      lookup
2293    } = this;
2294    const start = MathClamp(Math.round(src[srcOffset]), 0, highVal) * base.numComps;
2295    base.getRgbBuffer(lookup, start, 1, dest, destOffset, 8, 0);
2296  }
2297  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2298    const {
2299      base,
2300      highVal,
2301      lookup
2302    } = this;
2303    const {
2304      numComps
2305    } = base;
2306    const outputDelta = base.getOutputLength(numComps, alpha01);
2307    for (let i = 0; i < count; ++i) {
2308      const lookupPos = MathClamp(Math.round(src[srcOffset++]), 0, highVal) * numComps;
2309      base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);
2310      destOffset += outputDelta;
2311    }
2312  }
2313  getOutputLength(inputLength, alpha01) {
2314    return this.base.getOutputLength(inputLength * this.base.numComps, alpha01);
2315  }
2316  isDefaultDecode(decode, bpc) {
2317    if (isDefaultDecodeHelper(decode, 2)) {
2318      return true;
2319    }
2320    if (!Number.isInteger(bpc) || bpc < 1) {
2321      warn("Bits per component is not correct");
2322      return true;
2323    }
2324    return decode[0] === 0 && decode[1] === (1 << bpc) - 1;
2325  }
2326}
2327class DeviceGrayCS extends ColorSpace {
2328  constructor() {
2329    super("DeviceGray", 1);
2330  }
2331  getRgbItem(src, srcOffset, dest, destOffset) {
2332    const c = src[srcOffset] * 255;
2333    dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;
2334  }
2335  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2336    const scale = 255 / ((1 << bits) - 1);
2337    let j = srcOffset,
2338      q = destOffset;
2339    for (let i = 0; i < count; ++i) {
2340      const c = scale * src[j++];
2341      dest[q++] = c;
2342      dest[q++] = c;
2343      dest[q++] = c;
2344      q += alpha01;
2345    }
2346  }
2347  getOutputLength(inputLength, alpha01) {
2348    return inputLength * (3 + alpha01);
2349  }
2350}
2351class DeviceRgbCS extends ColorSpace {
2352  constructor() {
2353    super("DeviceRGB", 3);
2354  }
2355  getRgbItem(src, srcOffset, dest, destOffset) {
2356    dest[destOffset] = src[srcOffset] * 255;
2357    dest[destOffset + 1] = src[srcOffset + 1] * 255;
2358    dest[destOffset + 2] = src[srcOffset + 2] * 255;
2359  }
2360  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2361    if (bits === 8 && alpha01 === 0) {
2362      dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);
2363      return;
2364    }
2365    const scale = 255 / ((1 << bits) - 1);
2366    let j = srcOffset,
2367      q = destOffset;
2368    for (let i = 0; i < count; ++i) {
2369      dest[q++] = scale * src[j++];
2370      dest[q++] = scale * src[j++];
2371      dest[q++] = scale * src[j++];
2372      q += alpha01;
2373    }
2374  }
2375  getOutputLength(inputLength, alpha01) {
2376    return inputLength * (3 + alpha01) / 3 | 0;
2377  }
2378  isPassthrough(bits) {
2379    return bits === 8;
2380  }
2381}
2382class DeviceRgbaCS extends ColorSpace {
2383  constructor() {
2384    super("DeviceRGBA", 4);
2385  }
2386  getOutputLength(inputLength, _alpha01) {
2387    return inputLength * 4;
2388  }
2389  isPassthrough(bits) {
2390    return bits === 8;
2391  }
2392  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2393    if (originalHeight !== height || originalWidth !== width) {
2394      resizeRgbaImage(comps, dest, originalWidth, originalHeight, width, height, alpha01);
2395    } else {
2396      copyRgbaImage(comps, dest, alpha01);
2397    }
2398  }
2399}
2400class DeviceCmykCS extends ColorSpace {
2401  constructor() {
2402    super("DeviceCMYK", 4);
2403  }
2404  #toRgb(src, srcOffset, srcScale, dest, destOffset) {
2405    const c = src[srcOffset] * srcScale;
2406    const m = src[srcOffset + 1] * srcScale;
2407    const y = src[srcOffset + 2] * srcScale;
2408    const k = src[srcOffset + 3] * srcScale;
2409    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);
2410    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);
2411    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);
2412  }
2413  getRgbItem(src, srcOffset, dest, destOffset) {
2414    this.#toRgb(src, srcOffset, 1, dest, destOffset);
2415  }
2416  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2417    const scale = 1 / ((1 << bits) - 1);
2418    for (let i = 0; i < count; i++) {
2419      this.#toRgb(src, srcOffset, scale, dest, destOffset);
2420      srcOffset += 4;
2421      destOffset += 3 + alpha01;
2422    }
2423  }
2424  getOutputLength(inputLength, alpha01) {
2425    return inputLength / 4 * (3 + alpha01) | 0;
2426  }
2427}
2428class CalGrayCS extends ColorSpace {
2429  constructor(whitePoint, blackPoint, gamma) {
2430    super("CalGray", 1);
2431    if (!whitePoint) {
2432      throw new FormatError("WhitePoint missing - required for color space CalGray");
2433    }
2434    [this.XW, this.YW, this.ZW] = whitePoint;
2435    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2436    this.G = gamma || 1;
2437    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2438      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2439    }
2440    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2441      info(`Invalid BlackPoint for ${this.name}, falling back to default.`);
2442      this.XB = this.YB = this.ZB = 0;
2443    }
2444    if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {
2445      warn(`${this.name}, BlackPoint: XB: ${this.XB}, YB: ${this.YB}, ` + `ZB: ${this.ZB}, only default values are supported.`);
2446    }
2447    if (this.G < 1) {
2448      info(`Invalid Gamma: ${this.G} for ${this.name}, falling back to default.`);
2449      this.G = 1;
2450    }
2451  }
2452  #toRgb(src, srcOffset, dest, destOffset, scale) {
2453    const A = src[srcOffset] * scale;
2454    const AG = A ** this.G;
2455    const L = this.YW * AG;
2456    const val = Math.max(295.8 * L ** 0.3333333333333333 - 40.8, 0);
2457    dest[destOffset] = val;
2458    dest[destOffset + 1] = val;
2459    dest[destOffset + 2] = val;
2460  }
2461  getRgbItem(src, srcOffset, dest, destOffset) {
2462    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2463  }
2464  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2465    const scale = 1 / ((1 << bits) - 1);
2466    for (let i = 0; i < count; ++i) {
2467      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2468      srcOffset += 1;
2469      destOffset += 3 + alpha01;
2470    }
2471  }
2472  getOutputLength(inputLength, alpha01) {
2473    return inputLength * (3 + alpha01);
2474  }
2475}
2476class CalRGBCS extends ColorSpace {
2477  static #BRADFORD_SCALE_MATRIX = new Float32Array([0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296]);
2478  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]);
2479  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]);
2480  static #FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
2481  static #tempNormalizeMatrix = new Float32Array(3);
2482  static #tempConvertMatrix1 = new Float32Array(3);
2483  static #tempConvertMatrix2 = new Float32Array(3);
2484  static #DECODE_L_CONSTANT = ((8 + 16) / 116) ** 3 / 8.0;
2485  constructor(whitePoint, blackPoint, gamma, matrix) {
2486    super("CalRGB", 3);
2487    if (!whitePoint) {
2488      throw new FormatError("WhitePoint missing - required for color space CalRGB");
2489    }
2490    const [XW, YW, ZW] = this.whitePoint = whitePoint;
2491    const [XB, YB, ZB] = this.blackPoint = blackPoint || new Float32Array(3);
2492    [this.GR, this.GG, this.GB] = gamma || new Float32Array([1, 1, 1]);
2493    [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]);
2494    if (XW < 0 || ZW < 0 || YW !== 1) {
2495      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2496    }
2497    if (XB < 0 || YB < 0 || ZB < 0) {
2498      info(`Invalid BlackPoint for ${this.name} [${XB}, ${YB}, ${ZB}], ` + "falling back to default.");
2499      this.blackPoint = new Float32Array(3);
2500    }
2501    if (this.GR < 0 || this.GG < 0 || this.GB < 0) {
2502      info(`Invalid Gamma [${this.GR}, ${this.GG}, ${this.GB}] for ` + `${this.name}, falling back to default.`);
2503      this.GR = this.GG = this.GB = 1;
2504    }
2505  }
2506  #matrixProduct(a, b, result) {
2507    result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2508    result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
2509    result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
2510  }
2511  #toFlat(sourceWhitePoint, LMS, result) {
2512    result[0] = LMS[0] * 1 / sourceWhitePoint[0];
2513    result[1] = LMS[1] * 1 / sourceWhitePoint[1];
2514    result[2] = LMS[2] * 1 / sourceWhitePoint[2];
2515  }
2516  #toD65(sourceWhitePoint, LMS, result) {
2517    const D65X = 0.95047;
2518    const D65Y = 1;
2519    const D65Z = 1.08883;
2520    result[0] = LMS[0] * D65X / sourceWhitePoint[0];
2521    result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
2522    result[2] = LMS[2] * D65Z / sourceWhitePoint[2];
2523  }
2524  #sRGBTransferFunction(color) {
2525    if (color <= 0.0031308) {
2526      return MathClamp(12.92 * color, 0, 1);
2527    }
2528    if (color >= 0.99554525) {
2529      return 1;
2530    }
2531    return MathClamp((1 + 0.055) * color ** (1 / 2.4) - 0.055, 0, 1);
2532  }
2533  #decodeL(L) {
2534    if (L < 0) {
2535      return -this.#decodeL(-L);
2536    }
2537    if (L > 8.0) {
2538      return ((L + 16) / 116) ** 3;
2539    }
2540    return L * CalRGBCS.#DECODE_L_CONSTANT;
2541  }
2542  #compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
2543    if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {
2544      result[0] = XYZ_Flat[0];
2545      result[1] = XYZ_Flat[1];
2546      result[2] = XYZ_Flat[2];
2547      return;
2548    }
2549    const zeroDecodeL = this.#decodeL(0);
2550    const X_DST = zeroDecodeL;
2551    const X_SRC = this.#decodeL(sourceBlackPoint[0]);
2552    const Y_DST = zeroDecodeL;
2553    const Y_SRC = this.#decodeL(sourceBlackPoint[1]);
2554    const Z_DST = zeroDecodeL;
2555    const Z_SRC = this.#decodeL(sourceBlackPoint[2]);
2556    const X_Scale = (1 - X_DST) / (1 - X_SRC);
2557    const X_Offset = 1 - X_Scale;
2558    const Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
2559    const Y_Offset = 1 - Y_Scale;
2560    const Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
2561    const Z_Offset = 1 - Z_Scale;
2562    result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
2563    result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
2564    result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
2565  }
2566  #normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
2567    if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
2568      result[0] = XYZ_In[0];
2569      result[1] = XYZ_In[1];
2570      result[2] = XYZ_In[2];
2571      return;
2572    }
2573    const LMS = result;
2574    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2575    const LMS_Flat = CalRGBCS.#tempNormalizeMatrix;
2576    this.#toFlat(sourceWhitePoint, LMS, LMS_Flat);
2577    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
2578  }
2579  #normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
2580    const LMS = result;
2581    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2582    const LMS_D65 = CalRGBCS.#tempNormalizeMatrix;
2583    this.#toD65(sourceWhitePoint, LMS, LMS_D65);
2584    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
2585  }
2586  #toRgb(src, srcOffset, dest, destOffset, scale) {
2587    const A = MathClamp(src[srcOffset] * scale, 0, 1);
2588    const B = MathClamp(src[srcOffset + 1] * scale, 0, 1);
2589    const C = MathClamp(src[srcOffset + 2] * scale, 0, 1);
2590    const AGR = A === 1 ? 1 : A ** this.GR;
2591    const BGG = B === 1 ? 1 : B ** this.GG;
2592    const CGB = C === 1 ? 1 : C ** this.GB;
2593    const X = this.MXA * AGR + this.MXB * BGG + this.MXC * CGB;
2594    const Y = this.MYA * AGR + this.MYB * BGG + this.MYC * CGB;
2595    const Z = this.MZA * AGR + this.MZB * BGG + this.MZC * CGB;
2596    const XYZ = CalRGBCS.#tempConvertMatrix1;
2597    XYZ[0] = X;
2598    XYZ[1] = Y;
2599    XYZ[2] = Z;
2600    const XYZ_Flat = CalRGBCS.#tempConvertMatrix2;
2601    this.#normalizeWhitePointToFlat(this.whitePoint, XYZ, XYZ_Flat);
2602    const XYZ_Black = CalRGBCS.#tempConvertMatrix1;
2603    this.#compensateBlackPoint(this.blackPoint, XYZ_Flat, XYZ_Black);
2604    const XYZ_D65 = CalRGBCS.#tempConvertMatrix2;
2605    this.#normalizeWhitePointToD65(CalRGBCS.#FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);
2606    const SRGB = CalRGBCS.#tempConvertMatrix1;
2607    this.#matrixProduct(CalRGBCS.#SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
2608    dest[destOffset] = this.#sRGBTransferFunction(SRGB[0]) * 255;
2609    dest[destOffset + 1] = this.#sRGBTransferFunction(SRGB[1]) * 255;
2610    dest[destOffset + 2] = this.#sRGBTransferFunction(SRGB[2]) * 255;
2611  }
2612  getRgbItem(src, srcOffset, dest, destOffset) {
2613    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2614  }
2615  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2616    const scale = 1 / ((1 << bits) - 1);
2617    for (let i = 0; i < count; ++i) {
2618      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2619      srcOffset += 3;
2620      destOffset += 3 + alpha01;
2621    }
2622  }
2623  getOutputLength(inputLength, alpha01) {
2624    return inputLength * (3 + alpha01) / 3 | 0;
2625  }
2626}
2627class LabCS extends ColorSpace {
2628  constructor(whitePoint, blackPoint, range) {
2629    super("Lab", 3);
2630    if (!whitePoint) {
2631      throw new FormatError("WhitePoint missing - required for color space Lab");
2632    }
2633    [this.XW, this.YW, this.ZW] = whitePoint;
2634    [this.amin, this.amax, this.bmin, this.bmax] = range || [-100, 100, -100, 100];
2635    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2636    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2637      throw new FormatError("Invalid WhitePoint components, no fallback available");
2638    }
2639    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2640      info("Invalid BlackPoint, falling back to default");
2641      this.XB = this.YB = this.ZB = 0;
2642    }
2643    if (this.amin > this.amax || this.bmin > this.bmax) {
2644      info("Invalid Range, falling back to defaults");
2645      this.amin = -100;
2646      this.amax = 100;
2647      this.bmin = -100;
2648      this.bmax = 100;
2649    }
2650  }
2651  #fn_g(x) {
2652    return x >= 6 / 29 ? x ** 3 : 108 / 841 * (x - 4 / 29);
2653  }
2654  #decode(value, high1, low2, high2) {
2655    return low2 + value * (high2 - low2) / high1;
2656  }
2657  #toRgb(src, srcOffset, maxVal, dest, destOffset) {
2658    let Ls = src[srcOffset];
2659    let as = src[srcOffset + 1];
2660    let bs = src[srcOffset + 2];
2661    if (maxVal !== false) {
2662      Ls = this.#decode(Ls, maxVal, 0, 100);
2663      as = this.#decode(as, maxVal, this.amin, this.amax);
2664      bs = this.#decode(bs, maxVal, this.bmin, this.bmax);
2665    }
2666    if (as > this.amax) {
2667      as = this.amax;
2668    } else if (as < this.amin) {
2669      as = this.amin;
2670    }
2671    if (bs > this.bmax) {
2672      bs = this.bmax;
2673    } else if (bs < this.bmin) {
2674      bs = this.bmin;
2675    }
2676    const M = (Ls + 16) / 116;
2677    const L = M + as / 500;
2678    const N = M - bs / 200;
2679    const X = this.XW * this.#fn_g(L);
2680    const Y = this.YW * this.#fn_g(M);
2681    const Z = this.ZW * this.#fn_g(N);
2682    let r, g, b;
2683    if (this.ZW < 1) {
2684      r = X * 3.1339 + Y * -1.617 + Z * -0.4906;
2685      g = X * -0.9785 + Y * 1.916 + Z * 0.0333;
2686      b = X * 0.072 + Y * -0.229 + Z * 1.4057;
2687    } else {
2688      r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
2689      g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
2690      b = X * 0.0557 + Y * -0.204 + Z * 1.057;
2691    }
2692    dest[destOffset] = Math.sqrt(r) * 255;
2693    dest[destOffset + 1] = Math.sqrt(g) * 255;
2694    dest[destOffset + 2] = Math.sqrt(b) * 255;
2695  }
2696  getRgbItem(src, srcOffset, dest, destOffset) {
2697    this.#toRgb(src, srcOffset, false, dest, destOffset);
2698  }
2699  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2700    const maxVal = (1 << bits) - 1;
2701    for (let i = 0; i < count; i++) {
2702      this.#toRgb(src, srcOffset, maxVal, dest, destOffset);
2703      srcOffset += 3;
2704      destOffset += 3 + alpha01;
2705    }
2706  }
2707  getOutputLength(inputLength, alpha01) {
2708    return inputLength * (3 + alpha01) / 3 | 0;
2709  }
2710  isDefaultDecode(decode, bpc) {
2711    return true;
2712  }
2713  get usesZeroToOneRange() {
2714    return shadow(this, "usesZeroToOneRange", false);
2715  }
2716}
2717
2718;// ./src/core/icc_colorspace.js
2719
2720
2721
2722
2723function fetchSync(url) {
2724  const xhr = new XMLHttpRequest();
2725  xhr.open("GET", url, false);
2726  xhr.responseType = "arraybuffer";
2727  xhr.send(null);
2728  return xhr.response;
2729}
2730class IccColorSpace extends ColorSpace {
2731  #transformer;
2732  #convertPixel;
2733  static #useWasm = true;
2734  static #wasmUrl = null;
2735  static #finalizer = null;
2736  constructor(iccProfile, name, numComps) {
2737    if (!IccColorSpace.isUsable) {
2738      throw new Error("No ICC color space support");
2739    }
2740    super(name, numComps);
2741    let inType;
2742    switch (numComps) {
2743      case 1:
2744        inType = DataType.Gray8;
2745        this.#convertPixel = (src, srcOffset, css) => qcms_convert_one(this.#transformer, src[srcOffset] * 255, css);
2746        break;
2747      case 3:
2748        inType = DataType.RGB8;
2749        this.#convertPixel = (src, srcOffset, css) => qcms_convert_three(this.#transformer, src[srcOffset] * 255, src[srcOffset + 1] * 255, src[srcOffset + 2] * 255, css);
2750        break;
2751      case 4:
2752        inType = DataType.CMYK;
2753        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);
2754        break;
2755      default:
2756        throw new Error(`Unsupported number of components: ${numComps}`);
2757    }
2758    this.#transformer = qcms_transformer_from_memory(iccProfile, inType, Intent.Perceptual);
2759    if (!this.#transformer) {
2760      throw new Error("Failed to create ICC color space");
2761    }
2762    IccColorSpace.#finalizer ||= new FinalizationRegistry(transformer => {
2763      qcms_drop_transformer(transformer);
2764    });
2765    IccColorSpace.#finalizer.register(this, this.#transformer);
2766  }
2767  getRgbHex(src, srcOffset) {
2768    this.#convertPixel(src, srcOffset, true);
2769    return QCMS._cssColor;
2770  }
2771  getRgbItem(src, srcOffset, dest, destOffset) {
2772    QCMS._destBuffer = dest;
2773    QCMS._destOffset = destOffset;
2774    QCMS._destLength = 3;
2775    this.#convertPixel(src, srcOffset, false);
2776    QCMS._destBuffer = null;
2777  }
2778  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2779    src = src.subarray(srcOffset, srcOffset + count * this.numComps);
2780    if (bits !== 8) {
2781      const scale = 255 / ((1 << bits) - 1);
2782      for (let i = 0, ii = src.length; i < ii; i++) {
2783        src[i] *= scale;
2784      }
2785    }
2786    QCMS._mustAddAlpha = alpha01 && dest.buffer === src.buffer;
2787    QCMS._destBuffer = dest;
2788    QCMS._destOffset = destOffset;
2789    QCMS._destLength = count * (3 + alpha01);
2790    qcms_convert_array(this.#transformer, src);
2791    QCMS._mustAddAlpha = false;
2792    QCMS._destBuffer = null;
2793  }
2794  getOutputLength(inputLength, alpha01) {
2795    return inputLength / this.numComps * (3 + alpha01) | 0;
2796  }
2797  static setOptions({
2798    useWasm,
2799    useWorkerFetch,
2800    wasmUrl
2801  }) {
2802    if (!useWorkerFetch) {
2803      this.#useWasm = false;
2804      return;
2805    }
2806    this.#useWasm = useWasm;
2807    this.#wasmUrl = wasmUrl;
2808  }
2809  static get isUsable() {
2810    let isUsable = false;
2811    if (this.#useWasm) {
2812      if (this.#wasmUrl) {
2813        try {
2814          this._module = initSync({
2815            module: fetchSync(`${this.#wasmUrl}qcms_bg.wasm`)
2816          });
2817          isUsable = !!this._module;
2818          QCMS._memory = this._module.memory;
2819          QCMS._makeHexColor = Util.makeHexColor.bind(Util);
2820        } catch (e) {
2821          warn(`ICCBased color space: "${e}".`);
2822        }
2823      } else {
2824        warn("No ICC color space support due to missing `wasmUrl` API option");
2825      }
2826    }
2827    return shadow(this, "isUsable", isUsable);
2828  }
2829}
2830class CmykICCBasedCS extends IccColorSpace {
2831  static #iccUrl;
2832  constructor() {
2833    const iccProfile = new Uint8Array(fetchSync(`${CmykICCBasedCS.#iccUrl}CGATS001Compat-v2-micro.icc`));
2834    super(iccProfile, "DeviceCMYK", 4);
2835  }
2836  static setOptions({
2837    iccUrl
2838  }) {
2839    this.#iccUrl = iccUrl;
2840  }
2841  static get isUsable() {
2842    let isUsable = false;
2843    if (IccColorSpace.isUsable) {
2844      if (this.#iccUrl) {
2845        isUsable = true;
2846      } else {
2847        warn("No CMYK ICC profile support due to missing `iccUrl` API option");
2848      }
2849    }
2850    return shadow(this, "isUsable", isUsable);
2851  }
2852}
2853
2854;// ./src/core/stream.js
2855
2856
2857class Stream extends BaseStream {
2858  constructor(arrayBuffer, start, length, dict) {
2859    super();
2860    this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
2861    this.start = start || 0;
2862    this.pos = this.start;
2863    this.end = start + length || this.bytes.length;
2864    this.dict = dict;
2865  }
2866  get length() {
2867    return this.end - this.start;
2868  }
2869  get isEmpty() {
2870    return this.length === 0;
2871  }
2872  getByte() {
2873    if (this.pos >= this.end) {
2874      return -1;
2875    }
2876    return this.bytes[this.pos++];
2877  }
2878  getBytes(length) {
2879    const bytes = this.bytes;
2880    const pos = this.pos;
2881    const strEnd = this.end;
2882    if (!length) {
2883      this.pos = strEnd;
2884      return bytes.subarray(pos, strEnd);
2885    }
2886    let end = pos + length;
2887    if (end > strEnd) {
2888      end = strEnd;
2889    }
2890    this.pos = end;
2891    return bytes.subarray(pos, end);
2892  }
2893  getByteRange(begin, end) {
2894    if (begin < 0) {
2895      begin = 0;
2896    }
2897    if (end > this.end) {
2898      end = this.end;
2899    }
2900    return this.bytes.subarray(begin, end);
2901  }
2902  reset() {
2903    this.pos = this.start;
2904  }
2905  moveStart() {
2906    this.start = this.pos;
2907  }
2908  makeSubStream(start, length, dict = null) {
2909    return new Stream(this.bytes.buffer, start, length, dict);
2910  }
2911  clone() {
2912    return new Stream(this.bytes.buffer, this.start, this.end - this.start, this.dict.clone());
2913  }
2914}
2915class StringStream extends Stream {
2916  constructor(str) {
2917    super(stringToBytes(str));
2918  }
2919}
2920class NullStream extends Stream {
2921  constructor() {
2922    super(new Uint8Array(0));
2923  }
2924}
2925
2926;// ./src/core/chunked_stream.js
2927
2928
2929
2930
2931class ChunkedStream extends Stream {
2932  progressiveDataLength = 0;
2933  _lastSuccessfulEnsureByteChunk = -1;
2934  _loadedChunks = new Set();
2935  constructor(length, chunkSize, manager) {
2936    super(new Uint8Array(length), 0, length, null);
2937    this.chunkSize = chunkSize;
2938    this.numChunks = Math.ceil(length / chunkSize);
2939    this.manager = manager;
2940  }
2941  getMissingChunks() {
2942    const chunks = [];
2943    for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
2944      if (!this._loadedChunks.has(chunk)) {
2945        chunks.push(chunk);
2946      }
2947    }
2948    return chunks;
2949  }
2950  get numChunksLoaded() {
2951    return this._loadedChunks.size;
2952  }
2953  get isDataLoaded() {
2954    return this.numChunksLoaded === this.numChunks;
2955  }
2956  onReceiveData(begin, chunk) {
2957    const chunkSize = this.chunkSize;
2958    if (begin % chunkSize !== 0) {
2959      throw new Error(`Bad begin offset: ${begin}`);
2960    }
2961    const end = begin + chunk.byteLength;
2962    if (end % chunkSize !== 0 && end !== this.bytes.length) {
2963      throw new Error(`Bad end offset: ${end}`);
2964    }
2965    this.bytes.set(new Uint8Array(chunk), begin);
2966    const beginChunk = Math.floor(begin / chunkSize);
2967    const endChunk = Math.floor((end - 1) / chunkSize) + 1;
2968    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2969      this._loadedChunks.add(curChunk);
2970    }
2971  }
2972  onReceiveProgressiveData(data) {
2973    let position = this.progressiveDataLength;
2974    const beginChunk = Math.floor(position / this.chunkSize);
2975    this.bytes.set(new Uint8Array(data), position);
2976    position += data.byteLength;
2977    this.progressiveDataLength = position;
2978    const endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
2979    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2980      this._loadedChunks.add(curChunk);
2981    }
2982  }
2983  ensureByte(pos) {
2984    if (pos < this.progressiveDataLength) {
2985      return;
2986    }
2987    const chunk = Math.floor(pos / this.chunkSize);
2988    if (chunk > this.numChunks) {
2989      return;
2990    }
2991    if (chunk === this._lastSuccessfulEnsureByteChunk) {
2992      return;
2993    }
2994    if (!this._loadedChunks.has(chunk)) {
2995      throw new MissingDataException(pos, pos + 1);
2996    }
2997    this._lastSuccessfulEnsureByteChunk = chunk;
2998  }
2999  ensureRange(begin, end) {
3000    if (begin >= end) {
3001      return;
3002    }
3003    if (end <= this.progressiveDataLength) {
3004      return;
3005    }
3006    const beginChunk = Math.floor(begin / this.chunkSize);
3007    if (beginChunk > this.numChunks) {
3008      return;
3009    }
3010    const endChunk = Math.min(Math.floor((end - 1) / this.chunkSize) + 1, this.numChunks);
3011    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
3012      if (!this._loadedChunks.has(chunk)) {
3013        throw new MissingDataException(begin, end);
3014      }
3015    }
3016  }
3017  nextEmptyChunk(beginChunk) {
3018    const numChunks = this.numChunks;
3019    for (let i = 0; i < numChunks; ++i) {
3020      const chunk = (beginChunk + i) % numChunks;
3021      if (!this._loadedChunks.has(chunk)) {
3022        return chunk;
3023      }
3024    }
3025    return null;
3026  }
3027  hasChunk(chunk) {
3028    return this._loadedChunks.has(chunk);
3029  }
3030  getByte() {
3031    const pos = this.pos;
3032    if (pos >= this.end) {
3033      return -1;
3034    }
3035    if (pos >= this.progressiveDataLength) {
3036      this.ensureByte(pos);
3037    }
3038    return this.bytes[this.pos++];
3039  }
3040  getBytes(length) {
3041    const bytes = this.bytes;
3042    const pos = this.pos;
3043    const strEnd = this.end;
3044    if (!length) {
3045      if (strEnd > this.progressiveDataLength) {
3046        this.ensureRange(pos, strEnd);
3047      }
3048      this.pos = strEnd;
3049      return bytes.subarray(pos, strEnd);
3050    }
3051    let end = pos + length;
3052    if (end > strEnd) {
3053      end = strEnd;
3054    }
3055    if (end > this.progressiveDataLength) {
3056      this.ensureRange(pos, end);
3057    }
3058    this.pos = end;
3059    return bytes.subarray(pos, end);
3060  }
3061  getByteRange(begin, end) {
3062    if (begin < 0) {
3063      begin = 0;
3064    }
3065    if (end > this.end) {
3066      end = this.end;
3067    }
3068    if (end > this.progressiveDataLength) {
3069      this.ensureRange(begin, end);
3070    }
3071    return this.bytes.subarray(begin, end);
3072  }
3073  makeSubStream(start, length, dict = null) {
3074    if (length) {
3075      if (start + length > this.progressiveDataLength) {
3076        this.ensureRange(start, start + length);
3077      }
3078    } else if (start >= this.progressiveDataLength) {
3079      this.ensureByte(start);
3080    }
3081    function ChunkedStreamSubstream() {}
3082    ChunkedStreamSubstream.prototype = Object.create(this);
3083    ChunkedStreamSubstream.prototype.getMissingChunks = function () {
3084      const chunkSize = this.chunkSize;
3085      const beginChunk = Math.floor(this.start / chunkSize);