https://news.enechange.co.jp/js/pdf.worker.mjs

51
52const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
53const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
54const LINE_FACTOR = 1.35;
55const LINE_DESCENT_FACTOR = 0.35;
56const BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
57const RenderingIntentFlag = {
58  ANY: 0x01,
59  DISPLAY: 0x02,
60  PRINT: 0x04,
61  SAVE: 0x08,
62  ANNOTATIONS_FORMS: 0x10,
63  ANNOTATIONS_STORAGE: 0x20,
64  ANNOTATIONS_DISABLE: 0x40,
65  IS_EDITING: 0x80,
66  OPLIST: 0x100
67};
68const AnnotationMode = {
69  DISABLE: 0,
70  ENABLE: 1,
71  ENABLE_FORMS: 2,
72  ENABLE_STORAGE: 3
73};
74const AnnotationEditorPrefix = "pdfjs_internal_editor_";
75const AnnotationEditorType = {
76  DISABLE: -1,
77  NONE: 0,
78  FREETEXT: 3,
79  HIGHLIGHT: 9,
80  STAMP: 13,
81  INK: 15,
82  POPUP: 16,
83  SIGNATURE: 101,
84  COMMENT: 102
85};
86const AnnotationEditorParamsType = {
87  RESIZE: 1,
88  CREATE: 2,
89  FREETEXT_SIZE: 11,
90  FREETEXT_COLOR: 12,
91  FREETEXT_OPACITY: 13,
92  INK_COLOR: 21,
93  INK_THICKNESS: 22,
94  INK_OPACITY: 23,
95  HIGHLIGHT_COLOR: 31,
96  HIGHLIGHT_THICKNESS: 32,
97  HIGHLIGHT_FREE: 33,
98  HIGHLIGHT_SHOW_ALL: 34,
99  DRAW_STEP: 41
100};
101const PermissionFlag = {
102  PRINT: 0x04,
103  MODIFY_CONTENTS: 0x08,
104  COPY: 0x10,
105  MODIFY_ANNOTATIONS: 0x20,
106  FILL_INTERACTIVE_FORMS: 0x100,
107  COPY_FOR_ACCESSIBILITY: 0x200,
108  ASSEMBLE: 0x400,
109  PRINT_HIGH_QUALITY: 0x800
110};
111const TextRenderingMode = {
112  FILL: 0,
113  STROKE: 1,
114  FILL_STROKE: 2,
115  INVISIBLE: 3,
116  FILL_ADD_TO_PATH: 4,
117  STROKE_ADD_TO_PATH: 5,
118  FILL_STROKE_ADD_TO_PATH: 6,
119  ADD_TO_PATH: 7,
120  FILL_STROKE_MASK: 3,
121  ADD_TO_PATH_FLAG: 4
122};
123const ImageKind = {
124  GRAYSCALE_1BPP: 1,
125  RGB_24BPP: 2,
126  RGBA_32BPP: 3
127};
128const AnnotationType = {
129  TEXT: 1,
130  LINK: 2,
131  FREETEXT: 3,
132  LINE: 4,
133  SQUARE: 5,
134  CIRCLE: 6,
135  POLYGON: 7,
136  POLYLINE: 8,
137  HIGHLIGHT: 9,
138  UNDERLINE: 10,
139  SQUIGGLY: 11,
140  STRIKEOUT: 12,
141  STAMP: 13,
142  CARET: 14,
143  INK: 15,
144  POPUP: 16,
145  FILEATTACHMENT: 17,
146  SOUND: 18,
147  MOVIE: 19,
148  WIDGET: 20,
149  SCREEN: 21,
150  PRINTERMARK: 22,
151  TRAPNET: 23,
152  WATERMARK: 24,
153  THREED: 25,
154  REDACT: 26
155};
156const AnnotationReplyType = {
157  GROUP: "Group",
158  REPLY: "R"
159};
160const AnnotationFlag = {
161  INVISIBLE: 0x01,
162  HIDDEN: 0x02,
163  PRINT: 0x04,
164  NOZOOM: 0x08,
165  NOROTATE: 0x10,
166  NOVIEW: 0x20,
167  READONLY: 0x40,
168  LOCKED: 0x80,
169  TOGGLENOVIEW: 0x100,
170  LOCKEDCONTENTS: 0x200
171};
172const AnnotationFieldFlag = {
173  READONLY: 0x0000001,
174  REQUIRED: 0x0000002,
175  NOEXPORT: 0x0000004,
176  MULTILINE: 0x0001000,
177  PASSWORD: 0x0002000,
178  NOTOGGLETOOFF: 0x0004000,
179  RADIO: 0x0008000,
180  PUSHBUTTON: 0x0010000,
181  COMBO: 0x0020000,
182  EDIT: 0x0040000,
183  SORT: 0x0080000,
184  FILESELECT: 0x0100000,
185  MULTISELECT: 0x0200000,
186  DONOTSPELLCHECK: 0x0400000,
187  DONOTSCROLL: 0x0800000,
188  COMB: 0x1000000,
189  RICHTEXT: 0x2000000,
190  RADIOSINUNISON: 0x2000000,
191  COMMITONSELCHANGE: 0x4000000
192};
193const AnnotationBorderStyleType = {
194  SOLID: 1,
195  DASHED: 2,
196  BEVELED: 3,
197  INSET: 4,
198  UNDERLINE: 5
199};
200const AnnotationActionEventType = {
201  E: "Mouse Enter",
202  X: "Mouse Exit",
203  D: "Mouse Down",
204  U: "Mouse Up",
205  Fo: "Focus",
206  Bl: "Blur",
207  PO: "PageOpen",
208  PC: "PageClose",
209  PV: "PageVisible",
210  PI: "PageInvisible",
211  K: "Keystroke",
212  F: "Format",
213  V: "Validate",
214  C: "Calculate"
215};
216const DocumentActionEventType = {
217  WC: "WillClose",
218  WS: "WillSave",
219  DS: "DidSave",
220  WP: "WillPrint",
221  DP: "DidPrint"
222};
223const PageActionEventType = {
224  O: "PageOpen",
225  C: "PageClose"
226};
227const VerbosityLevel = {
228  ERRORS: 0,
229  WARNINGS: 1,
230  INFOS: 5
231};
232const OPS = {
233  dependency: 1,
234  setLineWidth: 2,
235  setLineCap: 3,
236  setLineJoin: 4,
237  setMiterLimit: 5,
238  setDash: 6,
239  setRenderingIntent: 7,
240  setFlatness: 8,
241  setGState: 9,
242  save: 10,
243  restore: 11,
244  transform: 12,
245  moveTo: 13,
246  lineTo: 14,
247  curveTo: 15,
248  curveTo2: 16,
249  curveTo3: 17,
250  closePath: 18,
251  rectangle: 19,
252  stroke: 20,
253  closeStroke: 21,
254  fill: 22,
255  eoFill: 23,
256  fillStroke: 24,
257  eoFillStroke: 25,
258  closeFillStroke: 26,
259  closeEOFillStroke: 27,
260  endPath: 28,
261  clip: 29,
262  eoClip: 30,
263  beginText: 31,
264  endText: 32,
265  setCharSpacing: 33,
266  setWordSpacing: 34,
267  setHScale: 35,
268  setLeading: 36,
269  setFont: 37,
270  setTextRenderingMode: 38,
271  setTextRise: 39,
272  moveText: 40,
273  setLeadingMoveText: 41,
274  setTextMatrix: 42,
275  nextLine: 43,
276  showText: 44,
277  showSpacedText: 45,
278  nextLineShowText: 46,
279  nextLineSetSpacingShowText: 47,
280  setCharWidth: 48,
281  setCharWidthAndBounds: 49,
282  setStrokeColorSpace: 50,
283  setFillColorSpace: 51,
284  setStrokeColor: 52,
285  setStrokeColorN: 53,
286  setFillColor: 54,
287  setFillColorN: 55,
288  setStrokeGray: 56,
289  setFillGray: 57,
290  setStrokeRGBColor: 58,
291  setFillRGBColor: 59,
292  setStrokeCMYKColor: 60,
293  setFillCMYKColor: 61,
294  shadingFill: 62,
295  beginInlineImage: 63,
296  beginImageData: 64,
297  endInlineImage: 65,
298  paintXObject: 66,
299  markPoint: 67,
300  markPointProps: 68,
301  beginMarkedContent: 69,
302  beginMarkedContentProps: 70,
303  endMarkedContent: 71,
304  beginCompat: 72,
305  endCompat: 73,
306  paintFormXObjectBegin: 74,
307  paintFormXObjectEnd: 75,
308  beginGroup: 76,
309  endGroup: 77,
310  beginAnnotation: 80,
311  endAnnotation: 81,
312  paintImageMaskXObject: 83,
313  paintImageMaskXObjectGroup: 84,
314  paintImageXObject: 85,
315  paintInlineImageXObject: 86,
316  paintInlineImageXObjectGroup: 87,
317  paintImageXObjectRepeat: 88,
318  paintImageMaskXObjectRepeat: 89,
319  paintSolidColorImageMask: 90,
320  constructPath: 91,
321  setStrokeTransparent: 92,
322  setFillTransparent: 93,
323  rawFillPath: 94
324};
325const DrawOPS = {
326  moveTo: 0,
327  lineTo: 1,
328  curveTo: 2,
329  closePath: 3
330};
331const PasswordResponses = {
332  NEED_PASSWORD: 1,
333  INCORRECT_PASSWORD: 2
334};
335let verbosity = VerbosityLevel.WARNINGS;
336function setVerbosityLevel(level) {
337  if (Number.isInteger(level)) {
338    verbosity = level;
339  }
340}
341function getVerbosityLevel() {
342  return verbosity;
343}
344function info(msg) {
345  if (verbosity >= VerbosityLevel.INFOS) {
346    console.info(`Info: ${msg}`);
347  }
348}
349function warn(msg) {
350  if (verbosity >= VerbosityLevel.WARNINGS) {
351    console.warn(`Warning: ${msg}`);
352  }
353}
354function unreachable(msg) {
355  throw new Error(msg);
356}
357function assert(cond, msg) {
358  if (!cond) {
359    unreachable(msg);
360  }
361}
362function _isValidProtocol(url) {
363  switch (url?.protocol) {
364    case "http:":
365    case "https:":
366    case "ftp:":
367    case "mailto:":
368    case "tel:":
369      return true;
370    default:
371      return false;
372  }
373}
374function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
375  if (!url) {
376    return null;
377  }
378  if (options && typeof url === "string") {
379    if (options.addDefaultProtocol && url.startsWith("www.")) {
380      const dots = url.match(/\./g);
381      if (dots?.length >= 2) {
382        url = `http://${url}`;
383      }
384    }
385    if (options.tryConvertEncoding) {
386      try {
387        url = stringToUTF8String(url);
388      } catch {}
389    }
390  }
391  const absoluteUrl = baseUrl ? URL.parse(url, baseUrl) : URL.parse(url);
392  return _isValidProtocol(absoluteUrl) ? absoluteUrl : null;
393}
394function updateUrlHash(url, hash, allowRel = false) {
395  const res = URL.parse(url);
396  if (res) {
397    res.hash = hash;
398    return res.href;
399  }
400  if (allowRel && createValidAbsoluteUrl(url, "http://example.com")) {
401    return url.split("#", 1)[0] + `${hash ? `#${hash}` : ""}`;
402  }
403  return "";
404}
405function shadow(obj, prop, value, nonSerializable = false) {
406  Object.defineProperty(obj, prop, {
407    value,
408    enumerable: !nonSerializable,
409    configurable: true,
410    writable: false
411  });
412  return value;
413}
414const BaseException = function BaseExceptionClosure() {
415  function BaseException(message, name) {
416    this.message = message;
417    this.name = name;
418  }
419  BaseException.prototype = new Error();
420  BaseException.constructor = BaseException;
421  return BaseException;
422}();
423class PasswordException extends BaseException {
424  constructor(msg, code) {
425    super(msg, "PasswordException");
426    this.code = code;
427  }
428}
429class UnknownErrorException extends BaseException {
430  constructor(msg, details) {
431    super(msg, "UnknownErrorException");
432    this.details = details;
433  }
434}
435class InvalidPDFException extends BaseException {
436  constructor(msg) {
437    super(msg, "InvalidPDFException");
438  }
439}
440class ResponseException extends BaseException {
441  constructor(msg, status, missing) {
442    super(msg, "ResponseException");
443    this.status = status;
444    this.missing = missing;
445  }
446}
447class FormatError extends BaseException {
448  constructor(msg) {
449    super(msg, "FormatError");
450  }
451}
452class AbortException extends BaseException {
453  constructor(msg) {
454    super(msg, "AbortException");
455  }
456}
457function bytesToString(bytes) {
458  if (typeof bytes !== "object" || bytes?.length === undefined) {
459    unreachable("Invalid argument for bytesToString");
460  }
461  const length = bytes.length;
462  const MAX_ARGUMENT_COUNT = 8192;
463  if (length < MAX_ARGUMENT_COUNT) {
464    return String.fromCharCode.apply(null, bytes);
465  }
466  const strBuf = [];
467  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
468    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
469    const chunk = bytes.subarray(i, chunkEnd);
470    strBuf.push(String.fromCharCode.apply(null, chunk));
471  }
472  return strBuf.join("");
473}
474function stringToBytes(str) {
475  if (typeof str !== "string") {
476    unreachable("Invalid argument for stringToBytes");
477  }
478  const length = str.length;
479  const bytes = new Uint8Array(length);
480  for (let i = 0; i < length; ++i) {
481    bytes[i] = str.charCodeAt(i) & 0xff;
482  }
483  return bytes;
484}
485function string32(value) {
486  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
487}
488function objectSize(obj) {
489  return Object.keys(obj).length;
490}
491function isLittleEndian() {
492  const buffer8 = new Uint8Array(4);
493  buffer8[0] = 1;
494  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
495  return view32[0] === 1;
496}
497function isEvalSupported() {
498  try {
499    new Function("");
500    return true;
501  } catch {
502    return false;
503  }
504}
505class FeatureTest {
506  static get isLittleEndian() {
507    return shadow(this, "isLittleEndian", isLittleEndian());
508  }
509  static get isEvalSupported() {
510    return shadow(this, "isEvalSupported", isEvalSupported());
511  }
512  static get isOffscreenCanvasSupported() {
513    return shadow(this, "isOffscreenCanvasSupported", typeof OffscreenCanvas !== "undefined");
514  }
515  static get isImageDecoderSupported() {
516    return shadow(this, "isImageDecoderSupported", typeof ImageDecoder !== "undefined");
517  }
518  static get platform() {
519    const {
520      platform,
521      userAgent
522    } = navigator;
523    return shadow(this, "platform", {
524      isAndroid: userAgent.includes("Android"),
525      isLinux: platform.includes("Linux"),
526      isMac: platform.includes("Mac"),
527      isWindows: platform.includes("Win"),
528      isFirefox: userAgent.includes("Firefox")
529    });
530  }
531  static get isCSSRoundSupported() {
532    return shadow(this, "isCSSRoundSupported", globalThis.CSS?.supports?.("width: round(1.5px, 1px)"));
533  }
534}
535const hexNumbers = Array.from(Array(256).keys(), n => n.toString(16).padStart(2, "0"));
536class Util {
537  static makeHexColor(r, g, b) {
538    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
539  }
540  static domMatrixToTransform(dm) {
541    return [dm.a, dm.b, dm.c, dm.d, dm.e, dm.f];
542  }
543  static scaleMinMax(transform, minMax) {
544    let temp;
545    if (transform[0]) {
546      if (transform[0] < 0) {
547        temp = minMax[0];
548        minMax[0] = minMax[2];
549        minMax[2] = temp;
550      }
551      minMax[0] *= transform[0];
552      minMax[2] *= transform[0];
553      if (transform[3] < 0) {
554        temp = minMax[1];
555        minMax[1] = minMax[3];
556        minMax[3] = temp;
557      }
558      minMax[1] *= transform[3];
559      minMax[3] *= transform[3];
560    } else {
561      temp = minMax[0];
562      minMax[0] = minMax[1];
563      minMax[1] = temp;
564      temp = minMax[2];
565      minMax[2] = minMax[3];
566      minMax[3] = temp;
567      if (transform[1] < 0) {
568        temp = minMax[1];
569        minMax[1] = minMax[3];
570        minMax[3] = temp;
571      }
572      minMax[1] *= transform[1];
573      minMax[3] *= transform[1];
574      if (transform[2] < 0) {
575        temp = minMax[0];
576        minMax[0] = minMax[2];
577        minMax[2] = temp;
578      }
579      minMax[0] *= transform[2];
580      minMax[2] *= transform[2];
581    }
582    minMax[0] += transform[4];
583    minMax[1] += transform[5];
584    minMax[2] += transform[4];
585    minMax[3] += transform[5];
586  }
587  static transform(m1, m2) {
588    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]];
589  }
590  static multiplyByDOMMatrix(m, md) {
591    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]];
592  }
593  static applyTransform(p, m, pos = 0) {
594    const p0 = p[pos];
595    const p1 = p[pos + 1];
596    p[pos] = p0 * m[0] + p1 * m[2] + m[4];
597    p[pos + 1] = p0 * m[1] + p1 * m[3] + m[5];
598  }
599  static applyTransformToBezier(p, transform, pos = 0) {
600    const m0 = transform[0];
601    const m1 = transform[1];
602    const m2 = transform[2];
603    const m3 = transform[3];
604    const m4 = transform[4];
605    const m5 = transform[5];
606    for (let i = 0; i < 6; i += 2) {
607      const pI = p[pos + i];
608      const pI1 = p[pos + i + 1];
609      p[pos + i] = pI * m0 + pI1 * m2 + m4;
610      p[pos + i + 1] = pI * m1 + pI1 * m3 + m5;
611    }
612  }
613  static applyInverseTransform(p, m) {
614    const p0 = p[0];
615    const p1 = p[1];
616    const d = m[0] * m[3] - m[1] * m[2];
617    p[0] = (p0 * m[3] - p1 * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
618    p[1] = (-p0 * m[1] + p1 * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
619  }
620  static axialAlignedBoundingBox(rect, transform, output) {
621    const m0 = transform[0];
622    const m1 = transform[1];
623    const m2 = transform[2];
624    const m3 = transform[3];
625    const m4 = transform[4];
626    const m5 = transform[5];
627    const r0 = rect[0];
628    const r1 = rect[1];
629    const r2 = rect[2];
630    const r3 = rect[3];
631    let a0 = m0 * r0 + m4;
632    let a2 = a0;
633    let a1 = m0 * r2 + m4;
634    let a3 = a1;
635    let b0 = m3 * r1 + m5;
636    let b2 = b0;
637    let b1 = m3 * r3 + m5;
638    let b3 = b1;
639    if (m1 !== 0 || m2 !== 0) {
640      const m1r0 = m1 * r0;
641      const m1r2 = m1 * r2;
642      const m2r1 = m2 * r1;
643      const m2r3 = m2 * r3;
644      a0 += m2r1;
645      a3 += m2r1;
646      a1 += m2r3;
647      a2 += m2r3;
648      b0 += m1r0;
649      b3 += m1r0;
650      b1 += m1r2;
651      b2 += m1r2;
652    }
653    output[0] = Math.min(output[0], a0, a1, a2, a3);
654    output[1] = Math.min(output[1], b0, b1, b2, b3);
655    output[2] = Math.max(output[2], a0, a1, a2, a3);
656    output[3] = Math.max(output[3], b0, b1, b2, b3);
657  }
658  static inverseTransform(m) {
659    const d = m[0] * m[3] - m[1] * m[2];
660    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];
661  }
662  static singularValueDecompose2dScale(matrix, output) {
663    const m0 = matrix[0];
664    const m1 = matrix[1];
665    const m2 = matrix[2];
666    const m3 = matrix[3];
667    const a = m0 ** 2 + m1 ** 2;
668    const b = m0 * m2 + m1 * m3;
669    const c = m2 ** 2 + m3 ** 2;
670    const first = (a + c) / 2;
671    const second = Math.sqrt(first ** 2 - (a * c - b ** 2));
672    output[0] = Math.sqrt(first + second || 1);
673    output[1] = Math.sqrt(first - second || 1);
674  }
675  static normalizeRect(rect) {
676    const r = rect.slice(0);
677    if (rect[0] > rect[2]) {
678      r[0] = rect[2];
679      r[2] = rect[0];
680    }
681    if (rect[1] > rect[3]) {
682      r[1] = rect[3];
683      r[3] = rect[1];
684    }
685    return r;
686  }
687  static intersect(rect1, rect2) {
688    const xLow = Math.max(Math.min(rect1[0], rect1[2]), Math.min(rect2[0], rect2[2]));
689    const xHigh = Math.min(Math.max(rect1[0], rect1[2]), Math.max(rect2[0], rect2[2]));
690    if (xLow > xHigh) {
691      return null;
692    }
693    const yLow = Math.max(Math.min(rect1[1], rect1[3]), Math.min(rect2[1], rect2[3]));
694    const yHigh = Math.min(Math.max(rect1[1], rect1[3]), Math.max(rect2[1], rect2[3]));
695    if (yLow > yHigh) {
696      return null;
697    }
698    return [xLow, yLow, xHigh, yHigh];
699  }
700  static pointBoundingBox(x, y, minMax) {
701    minMax[0] = Math.min(minMax[0], x);
702    minMax[1] = Math.min(minMax[1], y);
703    minMax[2] = Math.max(minMax[2], x);
704    minMax[3] = Math.max(minMax[3], y);
705  }
706  static rectBoundingBox(x0, y0, x1, y1, minMax) {
707    minMax[0] = Math.min(minMax[0], x0, x1);
708    minMax[1] = Math.min(minMax[1], y0, y1);
709    minMax[2] = Math.max(minMax[2], x0, x1);
710    minMax[3] = Math.max(minMax[3], y0, y1);
711  }
712  static #getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, t, minMax) {
713    if (t <= 0 || t >= 1) {
714      return;
715    }
716    const mt = 1 - t;
717    const tt = t * t;
718    const ttt = tt * t;
719    const x = mt * (mt * (mt * x0 + 3 * t * x1) + 3 * tt * x2) + ttt * x3;
720    const y = mt * (mt * (mt * y0 + 3 * t * y1) + 3 * tt * y2) + ttt * y3;
721    minMax[0] = Math.min(minMax[0], x);
722    minMax[1] = Math.min(minMax[1], y);
723    minMax[2] = Math.max(minMax[2], x);
724    minMax[3] = Math.max(minMax[3], y);
725  }
726  static #getExtremum(x0, x1, x2, x3, y0, y1, y2, y3, a, b, c, minMax) {
727    if (Math.abs(a) < 1e-12) {
728      if (Math.abs(b) >= 1e-12) {
729        this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, -c / b, minMax);
730      }
731      return;
732    }
733    const delta = b ** 2 - 4 * c * a;
734    if (delta < 0) {
735      return;
736    }
737    const sqrtDelta = Math.sqrt(delta);
738    const a2 = 2 * a;
739    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b + sqrtDelta) / a2, minMax);
740    this.#getExtremumOnCurve(x0, x1, x2, x3, y0, y1, y2, y3, (-b - sqrtDelta) / a2, minMax);
741  }
742  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3, minMax) {
743    minMax[0] = Math.min(minMax[0], x0, x3);
744    minMax[1] = Math.min(minMax[1], y0, y3);
745    minMax[2] = Math.max(minMax[2], x0, x3);
746    minMax[3] = Math.max(minMax[3], y0, y3);
747    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);
748    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);
749  }
750}
751const 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];
752function stringToPDFString(str, keepEscapeSequence = false) {
753  if (str[0] >= "\xEF") {
754    let encoding;
755    if (str[0] === "\xFE" && str[1] === "\xFF") {
756      encoding = "utf-16be";
757      if (str.length % 2 === 1) {
758        str = str.slice(0, -1);
759      }
760    } else if (str[0] === "\xFF" && str[1] === "\xFE") {
761      encoding = "utf-16le";
762      if (str.length % 2 === 1) {
763        str = str.slice(0, -1);
764      }
765    } else if (str[0] === "\xEF" && str[1] === "\xBB" && str[2] === "\xBF") {
766      encoding = "utf-8";
767    }
768    if (encoding) {
769      try {
770        const decoder = new TextDecoder(encoding, {
771          fatal: true
772        });
773        const buffer = stringToBytes(str);
774        const decoded = decoder.decode(buffer);
775        if (keepEscapeSequence || !decoded.includes("\x1b")) {
776          return decoded;
777        }
778        return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
779      } catch (ex) {
780        warn(`stringToPDFString: "${ex}".`);
781      }
782    }
783  }
784  const strBuf = [];
785  for (let i = 0, ii = str.length; i < ii; i++) {
786    const charCode = str.charCodeAt(i);
787    if (!keepEscapeSequence && charCode === 0x1b) {
788      while (++i < ii && str.charCodeAt(i) !== 0x1b) {}
789      continue;
790    }
791    const code = PDFStringTranslateTable[charCode];
792    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
793  }
794  return strBuf.join("");
795}
796function stringToUTF8String(str) {
797  return decodeURIComponent(escape(str));
798}
799function utf8StringToString(str) {
800  return unescape(encodeURIComponent(str));
801}
802function isArrayEqual(arr1, arr2) {
803  if (arr1.length !== arr2.length) {
804    return false;
805  }
806  for (let i = 0, ii = arr1.length; i < ii; i++) {
807    if (arr1[i] !== arr2[i]) {
808      return false;
809    }
810  }
811  return true;
812}
813function getModificationDate(date = new Date()) {
814  if (!(date instanceof Date)) {
815    date = new Date(date);
816  }
817  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")];
818  return buffer.join("");
819}
820let NormalizeRegex = null;
821let NormalizationMap = null;
822function normalizeUnicode(str) {
823  if (!NormalizeRegex) {
824    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;
825    NormalizationMap = new Map([["ſt", "ſt"]]);
826  }
827  return str.replaceAll(NormalizeRegex, (_, p1, p2) => p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2));
828}
829function getUuid() {
830  if (typeof crypto.randomUUID === "function") {
831    return crypto.randomUUID();
832  }
833  const buf = new Uint8Array(32);
834  crypto.getRandomValues(buf);
835  return bytesToString(buf);
836}
837const AnnotationPrefix = "pdfjs_internal_id_";
838function _isValidExplicitDest(validRef, validName, dest) {
839  if (!Array.isArray(dest) || dest.length < 2) {
840    return false;
841  }
842  const [page, zoom, ...args] = dest;
843  if (!validRef(page) && !Number.isInteger(page)) {
844    return false;
845  }
846  if (!validName(zoom)) {
847    return false;
848  }
849  const argsLen = args.length;
850  let allowNull = true;
851  switch (zoom.name) {
852    case "XYZ":
853      if (argsLen < 2 || argsLen > 3) {
854        return false;
855      }
856      break;
857    case "Fit":
858    case "FitB":
859      return argsLen === 0;
860    case "FitH":
861    case "FitBH":
862    case "FitV":
863    case "FitBV":
864      if (argsLen > 1) {
865        return false;
866      }
867      break;
868    case "FitR":
869      if (argsLen !== 4) {
870        return false;
871      }
872      allowNull = false;
873      break;
874    default:
875      return false;
876  }
877  for (const arg of args) {
878    if (typeof arg === "number" || allowNull && arg === null) {
879      continue;
880    }
881    return false;
882  }
883  return true;
884}
885function MathClamp(v, min, max) {
886  return Math.min(Math.max(v, min), max);
887}
888function toHexUtil(arr) {
889  if (Uint8Array.prototype.toHex) {
890    return arr.toHex();
891  }
892  return Array.from(arr, num => hexNumbers[num]).join("");
893}
894function toBase64Util(arr) {
895  if (Uint8Array.prototype.toBase64) {
896    return arr.toBase64();
897  }
898  return btoa(bytesToString(arr));
899}
900function fromBase64Util(str) {
901  if (Uint8Array.fromBase64) {
902    return Uint8Array.fromBase64(str);
903  }
904  return stringToBytes(atob(str));
905}
906if (typeof 

919
920
921const CIRCULAR_REF = Symbol("CIRCULAR_REF");
922const EOF = Symbol("EOF");
923let CmdCache = Object.create(null);
924let NameCache = Object.create(null);
925let RefCache = Object.create(null);
926function clearPrimitiveCaches() {
927  CmdCache = Object.create(null);
928  NameCache = Object.create(null);
929  RefCache = Object.create(null);
930}
931class Name {
932  constructor(name) {
933    this.name = name;
934  }
935  static get(name) {
936    return NameCache[name] ||= new Name(name);
937  }
938}
939class Cmd {
940  constructor(cmd) {
941    this.cmd = cmd;
942  }
943  static get(cmd) {
944    return CmdCache[cmd] ||= new Cmd(cmd);
945  }
946}
947const nonSerializable = function nonSerializableClosure() {
948  return nonSerializable;
949};
950class Dict {
951  constructor(xref = null) {
952    this._map = new Map();
953    this.xref = xref;
954    this.objId = null;
955    this.suppressEncryption = false;
956    this.__nonSerializable__ = nonSerializable;
957  }
958  assignXref(newXref) {
959    this.xref = newXref;
960  }
961  get size() {
962    return this._map.size;
963  }
964  get(key1, key2, key3) {
965    let value = this._map.get(key1);
966    if (value === undefined && key2 !== undefined) {
967      value = this._map.get(key2);
968      if (value === undefined && key3 !== undefined) {
969        value = this._map.get(key3);
970      }
971    }
972    if (value instanceof Ref && this.xref) {
973      return this.xref.fetch(value, this.suppressEncryption);
974    }
975    return value;
976  }
977  async getAsync(key1, key2, key3) {
978    let value = this._map.get(key1);
979    if (value === undefined && key2 !== undefined) {
980      value = this._map.get(key2);
981      if (value === undefined && key3 !== undefined) {
982        value = this._map.get(key3);
983      }
984    }
985    if (value instanceof Ref && this.xref) {
986      return this.xref.fetchAsync(value, this.suppressEncryption);
987    }
988    return value;
989  }
990  getArray(key1, key2, key3) {
991    let value = this._map.get(key1);
992    if (value === undefined && key2 !== undefined) {
993      value = this._map.get(key2);
994      if (value === undefined && key3 !== undefined) {
995        value = this._map.get(key3);
996      }
997    }
998    if (value instanceof Ref && this.xref) {
999      value = this.xref.fetch(value, this.suppressEncryption);
1000    }
1001    if (Array.isArray(value)) {
1002      value = value.slice();
1003      for (let i = 0, ii = value.length; i < ii; i++) {
1004        if (value[i] instanceof Ref && this.xref) {
1005          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
1006        }
1007      }
1008    }
1009    return value;
1010  }
1011  getRaw(key) {
1012    return this._map.get(key);
1013  }
1014  getKeys() {
1015    return [...this._map.keys()];
1016  }
1017  getRawValues() {
1018    return [...this._map.values()];
1019  }
1020  set(key, value) {
1021    this._map.set(key, value);
1022  }
1023  setIfNotExists(key, value) {
1024    if (!this.has(key)) {
1025      this.set(key, value);
1026    }
1027  }
1028  setIfNumber(key, value) {
1029    if (typeof value === "number") {
1030      this.set(key, value);
1031    }
1032  }
1033  setIfArray(key, value) {
1034    if (Array.isArray(value) || ArrayBuffer.isView(value)) {
1035      this.set(key, value);
1036    }
1037  }
1038  setIfDefined(key, value) {
1039    if (value !== undefined && value !== null) {
1040      this.set(key, value);
1041    }
1042  }
1043  setIfName(key, value) {
1044    if (typeof value === "string") {
1045      this.set(key, Name.get(value));
1046    } else if (value instanceof Name) {
1047      this.set(key, value);
1048    }
1049  }
1050  has(key) {
1051    return this._map.has(key);
1052  }
1053  *[Symbol.iterator]() {
1054    for (const [key, value] of this._map) {
1055      yield [key, value instanceof Ref && this.xref ? this.xref.fetch(value, this.suppressEncryption) : value];
1056    }
1057  }
1058  static get empty() {
1059    const emptyDict = new Dict(null);
1060    emptyDict.set = (key, value) => {
1061      unreachable("Should not call `set` on the empty dictionary.");
1062    };
1063    return shadow(this, "empty", emptyDict);
1064  }
1065  static merge({
1066    xref,
1067    dictArray,
1068    mergeSubDicts = false
1069  }) {
1070    const mergedDict = new Dict(xref),
1071      properties = new Map();
1072    for (const dict of dictArray) {
1073      if (!(dict instanceof Dict)) {
1074        continue;
1075      }
1076      for (const [key, value] of dict._map) {
1077        let property = properties.get(key);
1078        if (property === undefined) {
1079          property = [];
1080          properties.set(key, property);
1081        } else if (!mergeSubDicts || !(value instanceof Dict)) {
1082          continue;
1083        }
1084        property.push(value);
1085      }
1086    }
1087    for (const [name, values] of properties) {
1088      if (values.length === 1 || !(values[0] instanceof Dict)) {
1089        mergedDict._map.set(name, values[0]);
1090        continue;
1091      }
1092      const subDict = new Dict(xref);
1093      for (const dict of values) {
1094        for (const [key, value] of dict._map) {
1095          if (!subDict._map.has(key)) {
1096            subDict._map.set(key, value);
1097          }
1098        }
1099      }
1100      if (subDict.size > 0) {
1101        mergedDict._map.set(name, subDict);
1102      }
1103    }
1104    properties.clear();
1105    return mergedDict.size > 0 ? mergedDict : Dict.empty;
1106  }
1107  clone() {
1108    const dict = new Dict(this.xref);
1109    for (const key of this.getKeys()) {
1110      dict.set(key, this.getRaw(key));
1111    }
1112    return dict;
1113  }
1114  delete(key) {
1115    this._map.delete(key);
1116  }
1117}
1118class Ref {
1119  constructor(num, gen) {
1120    this.num = num;
1121    this.gen = gen;
1122  }
1123  toString() {
1124    if (this.gen === 0) {
1125      return `${this.num}R`;
1126    }
1127    return `${this.num}R${this.gen}`;
1128  }
1129  static fromString(str) {
1130    const ref = RefCache[str];
1131    if (ref) {
1132      return ref;
1133    }
1134    const m = /^(\d+)R(\d*)$/.exec(str);
1135    if (!m || m[1] === "0") {
1136      return null;
1137    }
1138    return RefCache[str] = new Ref(parseInt(m[1]), !m[2] ? 0 : parseInt(m[2]));
1139  }
1140  static get(num, gen) {
1141    const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
1142    return RefCache[key] ||= new Ref(num, gen);
1143  }
1144}
1145class RefSet {
1146  constructor(parent = null) {
1147    this._set = new Set(parent?._set);
1148  }
1149  has(ref) {
1150    return this._set.has(ref.toString());
1151  }
1152  put(ref) {
1153    this._set.add(ref.toString());
1154  }
1155  remove(ref) {
1156    this._set.delete(ref.toString());
1157  }
1158  [Symbol.iterator]() {
1159    return this._set.values();
1160  }
1161  clear() {
1162    this._set.clear();
1163  }
1164}
1165class RefSetCache {
1166  constructor() {
1167    this._map = new Map();
1168  }
1169  get size() {
1170    return this._map.size;
1171  }
1172  get(ref) {
1173    return this._map.get(ref.toString());
1174  }
1175  has(ref) {
1176    return this._map.has(ref.toString());
1177  }
1178  put(ref, obj) {
1179    this._map.set(ref.toString(), obj);
1180  }
1181  putAlias(ref, aliasRef) {
1182    this._map.set(ref.toString(), this.get(aliasRef));
1183  }
1184  [Symbol.iterator]() {
1185    return this._map.values();
1186  }
1187  clear() {
1188    this._map.clear();
1189  }
1190  *values() {
1191    yield* this._map.values();
1192  }
1193  *items() {
1194    for (const [ref, value] of this._map) {
1195      yield [Ref.fromString(ref), value];
1196    }
1197  }
1198}
1199function isName(v, name) {
1200  return v instanceof Name && (name === undefined || v.name === name);
1201}
1202function isCmd(v, cmd) {
1203  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
1204}
1205function isDict(v, type) {
1206  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
1207}
1208function isRefsEqual(v1, v2) {
1209  return v1.num === v2.num && v1.gen === v2.gen;
1210}
1211
1212;// ./src/core/base_stream.js
1213
1214class BaseStream {
1215  get length() {
1216    unreachable("Abstract getter `length` accessed");
1217  }
1218  get isEmpty() {
1219    unreachable("Abstract getter `isEmpty` accessed");
1220  }
1221  get isDataLoaded() {
1222    return shadow(this, "isDataLoaded", true);
1223  }
1224  getByte() {
1225    unreachable("Abstract method `getByte` called");
1226  }
1227  getBytes(length) {
1228    unreachable("Abstract method `getBytes` called");
1229  }
1230  async getImageData(length, decoderOptions) {
1231    return this.getBytes(length, decoderOptions);
1232  }
1233  async asyncGetBytes() {
1234    unreachable("Abstract method `asyncGetBytes` called");
1235  }
1236  get isAsync() {
1237    return false;
1238  }
1239  get isAsyncDecoder() {
1240    return false;
1241  }
1242  get canAsyncDecodeImageFromBuffer() {
1243    return false;
1244  }
1245  async getTransferableImage() {
1246    return null;
1247  }
1248  peekByte() {
1249    const peekedByte = this.getByte();
1250    if (peekedByte !== -1) {
1251      this.pos--;
1252    }
1253    return peekedByte;
1254  }
1255  peekBytes(length) {
1256    const bytes = this.getBytes(length);
1257    this.pos -= bytes.length;
1258    return bytes;
1259  }
1260  getUint16() {
1261    const b0 = this.getByte();
1262    const b1 = this.getByte();
1263    if (b0 === -1 || b1 === -1) {
1264      return -1;
1265    }
1266    return (b0 << 8) + b1;
1267  }
1268  getInt32() {
1269    const b0 = this.getByte();
1270    const b1 = this.getByte();
1271    const b2 = this.getByte();
1272    const b3 = this.getByte();
1273    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1274  }
1275  getByteRange(begin, end) {
1276    unreachable("Abstract method `getByteRange` called");
1277  }
1278  getString(length) {
1279    return bytesToString(this.getBytes(length));
1280  }
1281  skip(n) {
1282    this.pos += n || 1;
1283  }
1284  reset() {
1285    unreachable("Abstract method `reset` called");
1286  }
1287  moveStart() {
1288    unreachable("Abstract method `moveStart` called");
1289  }
1290  makeSubStream(start, length, dict = null) {
1291    unreachable("Abstract method `makeSubStream` called");
1292  }
1293  getBaseStreams() {
1294    return null;
1295  }
1296}
1297
1298;// ./src/core/core_utils.js
1299
1300
1301
1302const PDF_VERSION_REGEXP = /^[1-9]\.\d$/;
1303const MAX_INT_32 = 2 ** 31 - 1;
1304const MIN_INT_32 = -(2 ** 31);
1305const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
1306const RESOURCES_KEYS_OPERATOR_LIST = ["ColorSpace", "ExtGState", "Font", "Pattern", "Properties", "Shading", "XObject"];
1307const RESOURCES_KEYS_TEXT_CONTENT = ["ExtGState", "Font", "Properties", "XObject"];
1308function getLookupTableFactory(initializer) {
1309  let lookup;
1310  return function () {
1311    if (initializer) {
1312      lookup = Object.create(null);
1313      initializer(lookup);
1314      initializer = null;
1315    }
1316    return lookup;
1317  };
1318}
1319class MissingDataException extends BaseException {
1320  constructor(begin, end) {
1321    super(`Missing data [${begin}, ${end})`, "MissingDataException");
1322    this.begin = begin;
1323    this.end = end;
1324  }
1325}
1326class ParserEOFException extends BaseException {
1327  constructor(msg) {
1328    super(msg, "ParserEOFException");
1329  }
1330}
1331class XRefEntryException extends BaseException {
1332  constructor(msg) {
1333    super(msg, "XRefEntryException");
1334  }
1335}
1336class XRefParseException extends BaseException {
1337  constructor(msg) {
1338    super(msg, "XRefParseException");
1339  }
1340}
1341function arrayBuffersToBytes(arr) {
1342  const length = arr.length;
1343  if (length === 0) {
1344    return new Uint8Array(0);
1345  }
1346  if (length === 1) {
1347    return new Uint8Array(arr[0]);
1348  }
1349  let dataLength = 0;
1350  for (let i = 0; i < length; i++) {
1351    dataLength += arr[i].byteLength;
1352  }
1353  const data = new Uint8Array(dataLength);
1354  let pos = 0;
1355  for (let i = 0; i < length; i++) {
1356    const item = new Uint8Array(arr[i]);
1357    data.set(item, pos);
1358    pos += item.byteLength;
1359  }
1360  return data;
1361}
1362async function fetchBinaryData(url) {
1363  const response = await fetch(url);
1364  if (!response.ok) {
1365    throw new Error(`Failed to fetch file "${url}" with "${response.statusText}".`);
1366  }
1367  return new Uint8Array(await response.arrayBuffer());
1368}
1369function getInheritableProperty({
1370  dict,
1371  key,
1372  getArray = false,
1373  stopWhenFound = true
1374}) {
1375  let values;
1376  const visited = new RefSet();
1377  while (dict instanceof Dict && !(dict.objId && visited.has(dict.objId))) {
1378    if (dict.objId) {
1379      visited.put(dict.objId);
1380    }
1381    const value = getArray ? dict.getArray(key) : dict.get(key);
1382    if (value !== undefined) {
1383      if (stopWhenFound) {
1384        return value;
1385      }
1386      (values ||= []).push(value);
1387    }
1388    dict = dict.get("Parent");
1389  }
1390  return values;
1391}
1392function getParentToUpdate(dict, ref, xref) {
1393  const visited = new RefSet();
1394  const firstDict = dict;
1395  const result = {
1396    dict: null,
1397    ref: null
1398  };
1399  while (dict instanceof Dict && !visited.has(ref)) {
1400    visited.put(ref);
1401    if (dict.has("T")) {
1402      break;
1403    }
1404    ref = dict.getRaw("Parent");
1405    if (!(ref instanceof Ref)) {
1406      return result;
1407    }
1408    dict = xref.fetch(ref);
1409  }
1410  if (dict instanceof Dict && dict !== firstDict) {
1411    result.dict = dict;
1412    result.ref = ref;
1413  }
1414  return result;
1415}
1416const 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"];
1417function toRomanNumerals(number, lowerCase = false) {
1418  assert(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
1419  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];
1420  return lowerCase ? roman.toLowerCase() : roman;
1421}
1422function log2(x) {
1423  return x > 0 ? Math.ceil(Math.log2(x)) : 0;
1424}
1425function readInt8(data, offset) {
1426  return data[offset] << 24 >> 24;
1427}
1428function readInt16(data, offset) {
1429  return (data[offset] << 24 | data[offset + 1] << 16) >> 16;
1430}
1431function readUint16(data, offset) {
1432  return data[offset] << 8 | data[offset + 1];
1433}
1434function readUint32(data, offset) {
1435  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
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 of additionalActions.getKeys()) {
1556        const action = eventType[key];
1557        if (!action) {
1558          continue;
1559        }
1560        const actionDict = additionalActions.getRaw(key);
1561        const parents = new RefSet();
1562        const list = [];
1563        _collectJS(actionDict, xref, list, parents);
1564        if (list.length > 0) {
1565          actions[action] = list;
1566        }
1567      }
1568    }
1569  }
1570  if (dict.has("A")) {
1571    const actionDict = dict.get("A");
1572    const parents = new RefSet();
1573    const list = [];
1574    _collectJS(actionDict, xref, list, parents);
1575    if (list.length > 0) {
1576      actions.Action = list;
1577    }
1578  }
1579  return objectSize(actions) > 0 ? actions : null;
1580}
1581const XMLEntities = {
1582  0x3c: "&lt;",
1583  0x3e: "&gt;",
1584  0x26: "&amp;",
1585  0x22: "&quot;",
1586  0x27: "&apos;"
1587};
1588function* codePointIter(str) {
1589  for (let i = 0, ii = str.length; i < ii; i++) {
1590    const char = str.codePointAt(i);
1591    if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1592      i++;
1593    }
1594    yield char;
1595  }
1596}
1597function encodeToXmlString(str) {
1598  const buffer = [];
1599  let start = 0;
1600  for (let i = 0, ii = str.length; i < ii; i++) {
1601    const char = str.codePointAt(i);
1602    if (0x20 <= char && char <= 0x7e) {
1603      const entity = XMLEntities[char];
1604      if (entity) {
1605        if (start < i) {
1606          buffer.push(str.substring(start, i));
1607        }
1608        buffer.push(entity);
1609        start = i + 1;
1610      }
1611    } else {
1612      if (start < i) {
1613        buffer.push(str.substring(start, i));
1614      }
1615      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
1616      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1617        i++;
1618      }
1619      start = i + 1;
1620    }
1621  }
1622  if (buffer.length === 0) {
1623    return str;
1624  }
1625  if (start < str.length) {
1626    buffer.push(str.substring(start, str.length));
1627  }
1628  return buffer.join("");
1629}
1630function validateFontName(fontFamily, mustWarn = false) {
1631  const m = /^("|').*("|')$/.exec(fontFamily);
1632  if (m && m[1] === m[2]) {
1633    const re = new RegExp(`[^\\\\]${m[1]}`);
1634    if (re.test(fontFamily.slice(1, -1))) {
1635      if (mustWarn) {
1636        warn(`FontFamily contains unescaped ${m[1]}: ${fontFamily}.`);
1637      }
1638      return false;
1639    }
1640  } else {
1641    for (const ident of fontFamily.split(/[ \t]+/)) {
1642      if (/^(\d|(-(\d|-)))/.test(ident) || !/^[\w-\\]+$/.test(ident)) {
1643        if (mustWarn) {
1644          warn(`FontFamily contains invalid <custom-ident>: ${fontFamily}.`);
1645        }
1646        return false;
1647      }
1648    }
1649  }
1650  return true;
1651}
1652function validateCSSFont(cssFontInfo) {
1653  const DEFAULT_CSS_FONT_OBLIQUE = "14";
1654  const DEFAULT_CSS_FONT_WEIGHT = "400";
1655  const CSS_FONT_WEIGHT_VALUES = new Set(["100", "200", "300", "400", "500", "600", "700", "800", "900", "1000", "normal", "bold", "bolder", "lighter"]);
1656  const {
1657    fontFamily,
1658    fontWeight,
1659    italicAngle
1660  } = cssFontInfo;
1661  if (!validateFontName(fontFamily, true)) {
1662    return false;
1663  }
1664  const weight = fontWeight ? fontWeight.toString() : "";
1665  cssFontInfo.fontWeight = CSS_FONT_WEIGHT_VALUES.has(weight) ? weight : DEFAULT_CSS_FONT_WEIGHT;
1666  const angle = parseFloat(italicAngle);
1667  cssFontInfo.italicAngle = isNaN(angle) || angle < -90 || angle > 90 ? DEFAULT_CSS_FONT_OBLIQUE : italicAngle.toString();
1668  return true;
1669}
1670function recoverJsURL(str) {
1671  const URL_OPEN_METHODS = ["app.launchURL", "window.open", "xfa.host.gotoURL"];
1672  const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").replaceAll(".", "\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
1673  const jsUrl = regex.exec(str);
1674  if (jsUrl?.[2]) {
1675    return {
1676      url: jsUrl[2],
1677      newWindow: jsUrl[1] === "app.launchURL" && jsUrl[3] === "true"
1678    };
1679  }
1680  return null;
1681}
1682function numberToString(value) {
1683  if (Number.isInteger(value)) {
1684    return value.toString();
1685  }
1686  const roundedValue = Math.round(value * 100);
1687  if (roundedValue % 100 === 0) {
1688    return (roundedValue / 100).toString();
1689  }
1690  if (roundedValue % 10 === 0) {
1691    return value.toFixed(1);
1692  }
1693  return value.toFixed(2);
1694}
1695function getNewAnnotationsMap(annotationStorage) {
1696  if (!annotationStorage) {
1697    return null;
1698  }
1699  const newAnnotationsByPage = new Map();
1700  for (const [key, value] of annotationStorage) {
1701    if (!key.startsWith(AnnotationEditorPrefix)) {
1702      continue;
1703    }
1704    let annotations = newAnnotationsByPage.get(value.pageIndex);
1705    if (!annotations) {
1706      annotations = [];
1707      newAnnotationsByPage.set(value.pageIndex, annotations);
1708    }
1709    annotations.push(value);
1710  }
1711  return newAnnotationsByPage.size > 0 ? newAnnotationsByPage : null;
1712}
1713function stringToAsciiOrUTF16BE(str) {
1714  if (str === null || str === undefined) {
1715    return str;
1716  }
1717  return isAscii(str) ? str : stringToUTF16String(str, true);
1718}
1719function isAscii(str) {
1720  if (typeof str !== "string") {
1721    return false;
1722  }
1723  return !str || /^[\x00-\x7F]*$/.test(str);
1724}
1725function stringToUTF16HexString(str) {
1726  const buf = [];
1727  for (let i = 0, ii = str.length; i < ii; i++) {
1728    const char = str.charCodeAt(i);
1729    buf.push(hexNumbers[char >> 8 & 0xff], hexNumbers[char & 0xff]);
1730  }
1731  return buf.join("");
1732}
1733function stringToUTF16String(str, bigEndian = false) {
1734  const buf = [];
1735  if (bigEndian) {
1736    buf.push("\xFE\xFF");
1737  }
1738  for (let i = 0, ii = str.length; i < ii; i++) {
1739    const char = str.charCodeAt(i);
1740    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1741  }
1742  return buf.join("");
1743}
1744function getRotationMatrix(rotation, width, height) {
1745  switch (rotation) {
1746    case 90:
1747      return [0, 1, -1, 0, width, 0];
1748    case 180:
1749      return [-1, 0, 0, -1, width, height];
1750    case 270:
1751      return [0, -1, 1, 0, 0, height];
1752    default:
1753      throw new Error("Invalid rotation");
1754  }
1755}
1756function getSizeInBytes(x) {
1757  return Math.ceil(Math.ceil(Math.log2(1 + x)) / 8);
1758}
1759

1782    _destOffset,
1783    _destLength,
1784    _memoryArray
1785  } = QCMS;
1786  if (len === _destLength) {
1787    _destBuffer.set(_memoryArray.subarray(ptr, ptr + len), _destOffset);
1788    return;
1789  }
1790  if (_mustAddAlpha) {
1791    for (let i = ptr, ii = ptr + len, j = _destOffset; i < ii; i += 3, j += 4) {
1792      _destBuffer[j] = _memoryArray[i];
1793      _destBuffer[j + 1] = _memoryArray[i + 1];
1794      _destBuffer[j + 2] = _memoryArray[i + 2];
1795      _destBuffer[j + 3] = 255;
1796    }
1797  } else {
1798    for (let i = ptr, ii = ptr + len, j = _destOffset; i < ii; i += 3, j += 4) {
1799      _destBuffer[j] = _memoryArray[i];
1800      _destBuffer[j + 1] = _memoryArray[i + 1];
1801      _destBuffer[j + 2] = _memoryArray[i + 2];
1802    }
1803  }
1804}
1805function copy_rgb(ptr) {
1806  const {
1807    _destBuffer,
1808    _destOffset,
1809    _memoryArray
1810  } = QCMS;
1811  _destBuffer[_destOffset] = _memoryArray[ptr];
1812  _destBuffer[_destOffset + 1] = _memoryArray[ptr + 1];
1813  _destBuffer[_destOffset + 2] = _memoryArray[ptr + 2];
1814}
1815function make_cssRGB(ptr) {
1816  const {
1817    _memoryArray
1818  } = QCMS;
1819  QCMS._cssColor = QCMS._makeHexColor(_memoryArray[ptr], _memoryArray[ptr + 1], _memoryArray[ptr + 2]);
1820}
1821
1822;// ./external/qcms/qcms.js
1823
1824let wasm;
1825const cachedTextDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', {
1826  ignoreBOM: true,
1827  fatal: true
1828}) : {
1829  decode: () => {
1830    throw Error('TextDecoder not available');
1831  }
1832};
1833if (typeof TextDecoder !== 'undefined') {
1834  cachedTextDecoder.decode();
1835}
1836;
1837let cachedUint8ArrayMemory0 = null;
1838function getUint8ArrayMemory0() {
1839  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
1840    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
1841  }
1842  return cachedUint8ArrayMemory0;
1843}
1844function getStringFromWasm0(ptr, len) {
1845  ptr = ptr >>> 0;
1846  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
1847}
1848let WASM_VECTOR_LEN = 0;
1849function passArray8ToWasm0(arg, malloc) {
1850  const ptr = malloc(arg.length * 1, 1) >>> 0;
1851  getUint8ArrayMemory0().set(arg, ptr / 1);
1852  WASM_VECTOR_LEN = arg.length;
1853  return ptr;
1854}
1855function qcms_convert_array(transformer, src) {
1856  const ptr0 = passArray8ToWasm0(src, wasm.__wbindgen_malloc);
1857  const len0 = WASM_VECTOR_LEN;
1858  wasm.qcms_convert_array(transformer, ptr0, len0);
1859}
1860function qcms_convert_one(transformer, src, css) {
1861  wasm.qcms_convert_one(transformer, src, css);
1862}
1863function qcms_convert_three(transformer, src1, src2, src3, css) {
1864  wasm.qcms_convert_three(transformer, src1, src2, src3, css);
1865}
1866function qcms_convert_four(transformer, src1, src2, src3, src4, css) {
1867  wasm.qcms_convert_four(transformer, src1, src2, src3, src4, css);
1868}
1869function qcms_transformer_from_memory(mem, in_type, intent) {
1870  const ptr0 = passArray8ToWasm0(mem, wasm.__wbindgen_malloc);
1871  const len0 = WASM_VECTOR_LEN;
1872  const ret = wasm.qcms_transformer_from_memory(ptr0, len0, in_type, intent);
1873  return ret >>> 0;
1874}
1875function qcms_drop_transformer(transformer) {
1876  wasm.qcms_drop_transformer(transformer);
1877}
1878const DataType = Object.freeze({
1879  RGB8: 0,
1880  "0": "RGB8",
1881  RGBA8: 1,
1882  "1": "RGBA8",
1883  BGRA8: 2,
1884  "2": "BGRA8",
1885  Gray8: 3,
1886  "3": "Gray8",
1887  GrayA8: 4,
1888  "4": "GrayA8",
1889  CMYK: 5,
1890  "5": "CMYK"
1891});
1892const Intent = Object.freeze({
1893  Perceptual: 0,
1894  "0": "Perceptual",
1895  RelativeColorimetric: 1,
1896  "1": "RelativeColorimetric",
1897  Saturation: 2,
1898  "2": "Saturation",
1899  AbsoluteColorimetric: 3,
1900  "3": "AbsoluteColorimetric"
1901});
1902async function __wbg_load(module, imports) {
1903  if (typeof Response === 'function' && module instanceof Response) {
1904    if (typeof WebAssembly.instantiateStreaming === 'function') {
1905      try {
1906        return await WebAssembly.instantiateStreaming(module, imports);
1907      } catch (e) {
1908        if (module.headers.get('Content-Type') != 'application/wasm') {
1909          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);
1910        } else {
1911          throw e;
1912        }
1913      }
1914    }
1915    const bytes = await module.arrayBuffer();
1916    return await WebAssembly.instantiate(bytes, imports);
1917  } else {
1918    const instance = await WebAssembly.instantiate(module, imports);
1919    if (instance instanceof WebAssembly.Instance) {
1920      return {
1921        instance,
1922        module
1923      };
1924    } else {
1925      return instance;
1926    }
1927  }
1928}
1929function __wbg_get_imports() {
1930  const imports = {};
1931  imports.wbg = {};
1932  imports.wbg.__wbg_copyresult_b08ee7d273f295dd = function (arg0, arg1) {
1933    copy_result(arg0 >>> 0, arg1 >>> 0);
1934  };
1935  imports.wbg.__wbg_copyrgb_d60ce17bb05d9b67 = function (arg0) {
1936    copy_rgb(arg0 >>> 0);
1937  };
1938  imports.wbg.__wbg_makecssRGB_893bf0cd9fdb302d = function (arg0) {
1939    make_cssRGB(arg0 >>> 0);
1940  };
1941  imports.wbg.__wbindgen_init_externref_table = function () {
1942    const table = wasm.__wbindgen_export_0;
1943    const offset = table.grow(4);
1944    table.set(0, undefined);
1945    table.set(offset + 0, undefined);
1946    table.set(offset + 1, null);
1947    table.set(offset + 2, true);
1948    table.set(offset + 3, false);
1949  };
1950  imports.wbg.__wbindgen_throw = function (arg0, arg1) {
1951    throw new Error(getStringFromWasm0(arg0, arg1));
1952  };
1953  return imports;
1954}
1955function __wbg_init_memory(imports, memory) {}
1956function __wbg_finalize_init(instance, module) {
1957  wasm = instance.exports;
1958  __wbg_init.__wbindgen_wasm_module = module;
1959  cachedUint8ArrayMemory0 = null;
1960  wasm.__wbindgen_start();
1961  return wasm;
1962}
1963function initSync(module) {
1964  if (wasm !== undefined) return wasm;
1965  if (typeof module !== 'undefined') {
1966    if (Object.getPrototypeOf(module) === Object.prototype) {
1967      ({
1968        module
1969      } = module);
1970    } else {
1971      console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
1972    }
1973  }
1974  const imports = __wbg_get_imports();
1975  __wbg_init_memory(imports);
1976  if (!(module instanceof WebAssembly.Module)) {
1977    module = new WebAssembly.Module(module);
1978  }
1979  const instance = new WebAssembly.Instance(module, imports);
1980  return __wbg_finalize_init(instance, module);
1981}
1982async function __wbg_init(module_or_path) {
1983  if (wasm !== undefined) return wasm;
1984  if (typeof module_or_path !== 'undefined') {
1985    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
1986      ({
1987        module_or_path
1988      } = module_or_path);
1989    } else {
1990      console.warn('using deprecated parameters for the initialization function; pass a single object instead');
1991    }
1992  }
1993  const imports = __wbg_get_imports();
1994  if (typeof module_or_path === 'string' || typeof Request === 'function' && module_or_path instanceof Request || typeof URL === 'function' && module_or_path instanceof URL) {
1995    module_or_path = fetch(module_or_path);
1996  }
1997  __wbg_init_memory(imports);
1998  const {
1999    instance,
2000    module
2001  } = await __wbg_load(await module_or_path, imports);
2002  return __wbg_finalize_init(instance, module);
2003}
2004
2005/* harmony default export */ const qcms = ((/* unused pure expression or super */ null && (__wbg_init)));
2006;// ./src/core/colorspace.js

2006
2007
2008
2009function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
2010  const COMPONENTS = 3;
2011  alpha01 = alpha01 !== 1 ? 0 : alpha01;
2012  const xRatio = w1 / w2;
2013  const yRatio = h1 / h2;
2014  let newIndex = 0,
2015    oldIndex;
2016  const xScaled = new Uint16Array(w2);
2017  const w1Scanline = w1 * COMPONENTS;
2018  for (let i = 0; i < w2; i++) {
2019    xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
2020  }
2021  for (let i = 0; i < h2; i++) {
2022    const py = Math.floor(i * yRatio) * w1Scanline;
2023    for (let j = 0; j < w2; j++) {
2024      oldIndex = py + xScaled[j];
2025      dest[newIndex++] = src[oldIndex++];
2026      dest[newIndex++] = src[oldIndex++];
2027      dest[newIndex++] = src[oldIndex++];
2028      newIndex += alpha01;
2029    }
2030  }
2031}
2032function resizeRgbaImage(src, dest, w1, h1, w2, h2, alpha01) {
2033  const xRatio = w1 / w2;
2034  const yRatio = h1 / h2;
2035  let newIndex = 0;
2036  const xScaled = new Uint16Array(w2);
2037  if (alpha01 === 1) {
2038    for (let i = 0; i < w2; i++) {
2039      xScaled[i] = Math.floor(i * xRatio);
2040    }
2041    const src32 = new Uint32Array(src.buffer);
2042    const dest32 = new Uint32Array(dest.buffer);
2043    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2044    for (let i = 0; i < h2; i++) {
2045      const buf = src32.subarray(Math.floor(i * yRatio) * w1);
2046      for (let j = 0; j < w2; j++) {
2047        dest32[newIndex++] |= buf[xScaled[j]] & rgbMask;
2048      }
2049    }
2050  } else {
2051    const COMPONENTS = 4;
2052    const w1Scanline = w1 * COMPONENTS;
2053    for (let i = 0; i < w2; i++) {
2054      xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
2055    }
2056    for (let i = 0; i < h2; i++) {
2057      const buf = src.subarray(Math.floor(i * yRatio) * w1Scanline);
2058      for (let j = 0; j < w2; j++) {
2059        const oldIndex = xScaled[j];
2060        dest[newIndex++] = buf[oldIndex];
2061        dest[newIndex++] = buf[oldIndex + 1];
2062        dest[newIndex++] = buf[oldIndex + 2];
2063      }
2064    }
2065  }
2066}
2067function copyRgbaImage(src, dest, alpha01) {
2068  if (alpha01 === 1) {
2069    const src32 = new Uint32Array(src.buffer);
2070    const dest32 = new Uint32Array(dest.buffer);
2071    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2072    for (let i = 0, ii = src32.length; i < ii; i++) {
2073      dest32[i] |= src32[i] & rgbMask;
2074    }
2075  } else {
2076    let j = 0;
2077    for (let i = 0, ii = src.length; i < ii; i += 4) {
2078      dest[j++] = src[i];
2079      dest[j++] = src[i + 1];
2080      dest[j++] = src[i + 2];
2081    }
2082  }
2083}
2084class ColorSpace {
2085  static #rgbBuf = new Uint8ClampedArray(3);
2086  constructor(name, numComps) {
2087    this.name = name;
2088    this.numComps = numComps;
2089  }
2090  getRgb(src, srcOffset, output = new Uint8ClampedArray(3)) {
2091    this.getRgbItem(src, srcOffset, output, 0);
2092    return output;
2093  }
2094  getRgbHex(src, srcOffset) {
2095    const buffer = this.getRgb(src, srcOffset, ColorSpace.#rgbBuf);
2096    return Util.makeHexColor(buffer[0], buffer[1], buffer[2]);
2097  }
2098  getRgbItem(src, srcOffset, dest, destOffset) {
2099    unreachable("Should not call ColorSpace.getRgbItem");
2100  }
2101  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2102    unreachable("Should not call ColorSpace.getRgbBuffer");
2103  }
2104  getOutputLength(inputLength, alpha01) {
2105    unreachable("Should not call ColorSpace.getOutputLength");
2106  }
2107  isPassthrough(bits) {
2108    return false;
2109  }
2110  isDefaultDecode(decodeMap, bpc) {
2111    return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
2112  }
2113  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2114    const count = originalWidth * originalHeight;
2115    let rgbBuf = null;
2116    const numComponentColors = 1 << bpc;
2117    const needsResizing = originalHeight !== height || originalWidth !== width;
2118    if (this.isPassthrough(bpc)) {
2119      rgbBuf = comps;
2120    } else if (this.numComps === 1 && count > numComponentColors && this.name !== "DeviceGray" && this.name !== "DeviceRGB") {
2121      const allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : new Uint16Array(numComponentColors);
2122      for (let i = 0; i < numComponentColors; i++) {
2123        allColors[i] = i;
2124      }
2125      const colorMap = new Uint8ClampedArray(numComponentColors * 3);
2126      this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc, 0);
2127      if (!needsResizing) {
2128        let destPos = 0;
2129        for (let i = 0; i < count; ++i) {
2130          const key = comps[i] * 3;
2131          dest[destPos++] = colorMap[key];
2132          dest[destPos++] = colorMap[key + 1];
2133          dest[destPos++] = colorMap[key + 2];
2134          destPos += alpha01;
2135        }
2136      } else {
2137        rgbBuf = new Uint8Array(count * 3);
2138        let rgbPos = 0;
2139        for (let i = 0; i < count; ++i) {
2140          const key = comps[i] * 3;
2141          rgbBuf[rgbPos++] = colorMap[key];
2142          rgbBuf[rgbPos++] = colorMap[key + 1];
2143          rgbBuf[rgbPos++] = colorMap[key + 2];
2144        }
2145      }
2146    } else if (!needsResizing) {
2147      this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, alpha01);
2148    } else {
2149      rgbBuf = new Uint8ClampedArray(count * 3);
2150      this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, 0);
2151    }
2152    if (rgbBuf) {
2153      if (needsResizing) {
2154        resizeRgbImage(rgbBuf, dest, originalWidth, originalHeight, width, height, alpha01);
2155      } else {
2156        let destPos = 0,
2157          rgbPos = 0;
2158        for (let i = 0, ii = width * actualHeight; i < ii; i++) {
2159          dest[destPos++] = rgbBuf[rgbPos++];
2160          dest[destPos++] = rgbBuf[rgbPos++];
2161          dest[destPos++] = rgbBuf[rgbPos++];
2162          destPos += alpha01;
2163        }
2164      }
2165    }
2166  }
2167  get usesZeroToOneRange() {
2168    return shadow(this, "usesZeroToOneRange", true);
2169  }
2170  static isDefaultDecode(decode, numComps) {
2171    if (!Array.isArray(decode)) {
2172      return true;
2173    }
2174    if (numComps * 2 !== decode.length) {
2175      warn("The decode map is not the correct length");
2176      return true;
2177    }
2178    for (let i = 0, ii = decode.length; i < ii; i += 2) {
2179      if (decode[i] !== 0 || decode[i + 1] !== 1) {
2180        return false;
2181      }
2182    }
2183    return true;
2184  }
2185}
2186class AlternateCS extends ColorSpace {
2187  constructor(numComps, base, tintFn) {
2188    super("Alternate", numComps);
2189    this.base = base;
2190    this.tintFn = tintFn;
2191    this.tmpBuf = new Float32Array(base.numComps);
2192  }
2193  getRgbItem(src, srcOffset, dest, destOffset) {
2194    const tmpBuf = this.tmpBuf;
2195    this.tintFn(src, srcOffset, tmpBuf, 0);
2196    this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
2197  }
2198  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2199    const tintFn = this.tintFn;
2200    const base = this.base;
2201    const scale = 1 / ((1 << bits) - 1);
2202    const baseNumComps = base.numComps;
2203    const usesZeroToOneRange = base.usesZeroToOneRange;
2204    const isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) && alpha01 === 0;
2205    let pos = isPassthrough ? destOffset : 0;
2206    const baseBuf = isPassthrough ? dest : new Uint8ClampedArray(baseNumComps * count);
2207    const numComps = this.numComps;
2208    const scaled = new Float32Array(numComps);
2209    const tinted = new Float32Array(baseNumComps);
2210    let i, j;
2211    for (i = 0; i < count; i++) {
2212      for (j = 0; j < numComps; j++) {
2213        scaled[j] = src[srcOffset++] * scale;
2214      }
2215      tintFn(scaled, 0, tinted, 0);
2216      if (usesZeroToOneRange) {
2217        for (j = 0; j < baseNumComps; j++) {
2218          baseBuf[pos++] = tinted[j] * 255;
2219        }
2220      } else {
2221        base.getRgbItem(tinted, 0, baseBuf, pos);
2222        pos += baseNumComps;
2223      }
2224    }
2225    if (!isPassthrough) {
2226      base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);
2227    }
2228  }
2229  getOutputLength(inputLength, alpha01) {
2230    return this.base.getOutputLength(inputLength * this.base.numComps / this.numComps, alpha01);
2231  }
2232}
2233class PatternCS extends ColorSpace {
2234  constructor(baseCS) {
2235    super("Pattern", null);
2236    this.base = baseCS;
2237  }
2238  isDefaultDecode(decodeMap, bpc) {
2239    unreachable("Should not call PatternCS.isDefaultDecode");
2240  }
2241}
2242class IndexedCS extends ColorSpace {
2243  constructor(base, highVal, lookup) {
2244    super("Indexed", 1);
2245    this.base = base;
2246    this.highVal = highVal;
2247    const length = base.numComps * (highVal + 1);
2248    this.lookup = new Uint8Array(length);
2249    if (lookup instanceof BaseStream) {
2250      const bytes = lookup.getBytes(length);
2251      this.lookup.set(bytes);
2252    } else if (typeof lookup === "string") {
2253      for (let i = 0; i < length; ++i) {
2254        this.lookup[i] = lookup.charCodeAt(i) & 0xff;
2255      }
2256    } else {
2257      throw new FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);
2258    }
2259  }
2260  getRgbItem(src, srcOffset, dest, destOffset) {
2261    const {
2262      base,
2263      highVal,
2264      lookup
2265    } = this;
2266    const start = MathClamp(Math.round(src[srcOffset]), 0, highVal) * base.numComps;
2267    base.getRgbBuffer(lookup, start, 1, dest, destOffset, 8, 0);
2268  }
2269  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2270    const {
2271      base,
2272      highVal,
2273      lookup
2274    } = this;
2275    const {
2276      numComps
2277    } = base;
2278    const outputDelta = base.getOutputLength(numComps, alpha01);
2279    for (let i = 0; i < count; ++i) {
2280      const lookupPos = MathClamp(Math.round(src[srcOffset++]), 0, highVal) * numComps;
2281      base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);
2282      destOffset += outputDelta;
2283    }
2284  }
2285  getOutputLength(inputLength, alpha01) {
2286    return this.base.getOutputLength(inputLength * this.base.numComps, alpha01);
2287  }
2288  isDefaultDecode(decodeMap, bpc) {
2289    if (!Array.isArray(decodeMap)) {
2290      return true;
2291    }
2292    if (decodeMap.length !== 2) {
2293      warn("Decode map length is not correct");
2294      return true;
2295    }
2296    if (!Number.isInteger(bpc) || bpc < 1) {
2297      warn("Bits per component is not correct");
2298      return true;
2299    }
2300    return decodeMap[0] === 0 && decodeMap[1] === (1 << bpc) - 1;
2301  }
2302}
2303class DeviceGrayCS extends ColorSpace {
2304  constructor() {
2305    super("DeviceGray", 1);
2306  }
2307  getRgbItem(src, srcOffset, dest, destOffset) {
2308    const c = src[srcOffset] * 255;
2309    dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;
2310  }
2311  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2312    const scale = 255 / ((1 << bits) - 1);
2313    let j = srcOffset,
2314      q = destOffset;
2315    for (let i = 0; i < count; ++i) {
2316      const c = scale * src[j++];
2317      dest[q++] = c;
2318      dest[q++] = c;
2319      dest[q++] = c;
2320      q += alpha01;
2321    }
2322  }
2323  getOutputLength(inputLength, alpha01) {
2324    return inputLength * (3 + alpha01);
2325  }
2326}
2327class DeviceRgbCS extends ColorSpace {
2328  constructor() {
2329    super("DeviceRGB", 3);
2330  }
2331  getRgbItem(src, srcOffset, dest, destOffset) {
2332    dest[destOffset] = src[srcOffset] * 255;
2333    dest[destOffset + 1] = src[srcOffset + 1] * 255;
2334    dest[destOffset + 2] = src[srcOffset + 2] * 255;
2335  }
2336  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2337    if (bits === 8 && alpha01 === 0) {
2338      dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);
2339      return;
2340    }
2341    const scale = 255 / ((1 << bits) - 1);
2342    let j = srcOffset,
2343      q = destOffset;
2344    for (let i = 0; i < count; ++i) {
2345      dest[q++] = scale * src[j++];
2346      dest[q++] = scale * src[j++];
2347      dest[q++] = scale * src[j++];
2348      q += alpha01;
2349    }
2350  }
2351  getOutputLength(inputLength, alpha01) {
2352    return inputLength * (3 + alpha01) / 3 | 0;
2353  }
2354  isPassthrough(bits) {
2355    return bits === 8;
2356  }
2357}
2358class DeviceRgbaCS extends ColorSpace {
2359  constructor() {
2360    super("DeviceRGBA", 4);
2361  }
2362  getOutputLength(inputLength, _alpha01) {
2363    return inputLength * 4;
2364  }
2365  isPassthrough(bits) {
2366    return bits === 8;
2367  }
2368  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2369    if (originalHeight !== height || originalWidth !== width) {
2370      resizeRgbaImage(comps, dest, originalWidth, originalHeight, width, height, alpha01);
2371    } else {
2372      copyRgbaImage(comps, dest, alpha01);
2373    }
2374  }
2375}
2376class DeviceCmykCS extends ColorSpace {
2377  constructor() {
2378    super("DeviceCMYK", 4);
2379  }
2380  #toRgb(src, srcOffset, srcScale, dest, destOffset) {
2381    const c = src[srcOffset] * srcScale;
2382    const m = src[srcOffset + 1] * srcScale;
2383    const y = src[srcOffset + 2] * srcScale;
2384    const k = src[srcOffset + 3] * srcScale;
2385    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);
2386    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);
2387    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);
2388  }
2389  getRgbItem(src, srcOffset, dest, destOffset) {
2390    this.#toRgb(src, srcOffset, 1, dest, destOffset);
2391  }
2392  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2393    const scale = 1 / ((1 << bits) - 1);
2394    for (let i = 0; i < count; i++) {
2395      this.#toRgb(src, srcOffset, scale, dest, destOffset);
2396      srcOffset += 4;
2397      destOffset += 3 + alpha01;
2398    }
2399  }
2400  getOutputLength(inputLength, alpha01) {
2401    return inputLength / 4 * (3 + alpha01) | 0;
2402  }
2403}
2404class CalGrayCS extends ColorSpace {
2405  constructor(whitePoint, blackPoint, gamma) {
2406    super("CalGray", 1);
2407    if (!whitePoint) {
2408      throw new FormatError("WhitePoint missing - required for color space CalGray");
2409    }
2410    [this.XW, this.YW, this.ZW] = whitePoint;
2411    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2412    this.G = gamma || 1;
2413    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2414      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2415    }
2416    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2417      info(`Invalid BlackPoint for ${this.name}, falling back to default.`);
2418      this.XB = this.YB = this.ZB = 0;
2419    }
2420    if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {
2421      warn(`${this.name}, BlackPoint: XB: ${this.XB}, YB: ${this.YB}, ` + `ZB: ${this.ZB}, only default values are supported.`);
2422    }
2423    if (this.G < 1) {
2424      info(`Invalid Gamma: ${this.G} for ${this.name}, falling back to default.`);
2425      this.G = 1;
2426    }
2427  }
2428  #toRgb(src, srcOffset, dest, destOffset, scale) {
2429    const A = src[srcOffset] * scale;
2430    const AG = A ** this.G;
2431    const L = this.YW * AG;
2432    const val = Math.max(295.8 * L ** 0.3333333333333333 - 40.8, 0);
2433    dest[destOffset] = val;
2434    dest[destOffset + 1] = val;
2435    dest[destOffset + 2] = val;
2436  }
2437  getRgbItem(src, srcOffset, dest, destOffset) {
2438    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2439  }
2440  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2441    const scale = 1 / ((1 << bits) - 1);
2442    for (let i = 0; i < count; ++i) {
2443      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2444      srcOffset += 1;
2445      destOffset += 3 + alpha01;
2446    }
2447  }
2448  getOutputLength(inputLength, alpha01) {
2449    return inputLength * (3 + alpha01);
2450  }
2451}
2452class CalRGBCS extends ColorSpace {
2453  static #BRADFORD_SCALE_MATRIX = new Float32Array([0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296]);
2454  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]);
2455  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]);
2456  static #FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
2457  static #tempNormalizeMatrix = new Float32Array(3);
2458  static #tempConvertMatrix1 = new Float32Array(3);
2459  static #tempConvertMatrix2 = new Float32Array(3);
2460  static #DECODE_L_CONSTANT = ((8 + 16) / 116) ** 3 / 8.0;
2461  constructor(whitePoint, blackPoint, gamma, matrix) {
2462    super("CalRGB", 3);
2463    if (!whitePoint) {
2464      throw new FormatError("WhitePoint missing - required for color space CalRGB");
2465    }
2466    const [XW, YW, ZW] = this.whitePoint = whitePoint;
2467    const [XB, YB, ZB] = this.blackPoint = blackPoint || new Float32Array(3);
2468    [this.GR, this.GG, this.GB] = gamma || new Float32Array([1, 1, 1]);
2469    [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]);
2470    if (XW < 0 || ZW < 0 || YW !== 1) {
2471      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2472    }
2473    if (XB < 0 || YB < 0 || ZB < 0) {
2474      info(`Invalid BlackPoint for ${this.name} [${XB}, ${YB}, ${ZB}], ` + "falling back to default.");
2475      this.blackPoint = new Float32Array(3);
2476    }
2477    if (this.GR < 0 || this.GG < 0 || this.GB < 0) {
2478      info(`Invalid Gamma [${this.GR}, ${this.GG}, ${this.GB}] for ` + `${this.name}, falling back to default.`);
2479      this.GR = this.GG = this.GB = 1;
2480    }
2481  }
2482  #matrixProduct(a, b, result) {
2483    result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2484    result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
2485    result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
2486  }
2487  #toFlat(sourceWhitePoint, LMS, result) {
2488    result[0] = LMS[0] * 1 / sourceWhitePoint[0];
2489    result[1] = LMS[1] * 1 / sourceWhitePoint[1];
2490    result[2] = LMS[2] * 1 / sourceWhitePoint[2];
2491  }
2492  #toD65(sourceWhitePoint, LMS, result) {
2493    const D65X = 0.95047;
2494    const D65Y = 1;
2495    const D65Z = 1.08883;
2496    result[0] = LMS[0] * D65X / sourceWhitePoint[0];
2497    result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
2498    result[2] = LMS[2] * D65Z / sourceWhitePoint[2];
2499  }
2500  #sRGBTransferFunction(color) {
2501    if (color <= 0.0031308) {
2502      return MathClamp(12.92 * color, 0, 1);
2503    }
2504    if (color >= 0.99554525) {
2505      return 1;
2506    }
2507    return MathClamp((1 + 0.055) * color ** (1 / 2.4) - 0.055, 0, 1);
2508  }
2509  #decodeL(L) {
2510    if (L < 0) {
2511      return -this.#decodeL(-L);
2512    }
2513    if (L > 8.0) {
2514      return ((L + 16) / 116) ** 3;
2515    }
2516    return L * CalRGBCS.#DECODE_L_CONSTANT;
2517  }
2518  #compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
2519    if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {
2520      result[0] = XYZ_Flat[0];
2521      result[1] = XYZ_Flat[1];
2522      result[2] = XYZ_Flat[2];
2523      return;
2524    }
2525    const zeroDecodeL = this.#decodeL(0);
2526    const X_DST = zeroDecodeL;
2527    const X_SRC = this.#decodeL(sourceBlackPoint[0]);
2528    const Y_DST = zeroDecodeL;
2529    const Y_SRC = this.#decodeL(sourceBlackPoint[1]);
2530    const Z_DST = zeroDecodeL;
2531    const Z_SRC = this.#decodeL(sourceBlackPoint[2]);
2532    const X_Scale = (1 - X_DST) / (1 - X_SRC);
2533    const X_Offset = 1 - X_Scale;
2534    const Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
2535    const Y_Offset = 1 - Y_Scale;
2536    const Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
2537    const Z_Offset = 1 - Z_Scale;
2538    result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
2539    result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
2540    result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
2541  }
2542  #normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
2543    if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
2544      result[0] = XYZ_In[0];
2545      result[1] = XYZ_In[1];
2546      result[2] = XYZ_In[2];
2547      return;
2548    }
2549    const LMS = result;
2550    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2551    const LMS_Flat = CalRGBCS.#tempNormalizeMatrix;
2552    this.#toFlat(sourceWhitePoint, LMS, LMS_Flat);
2553    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
2554  }
2555  #normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
2556    const LMS = result;
2557    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2558    const LMS_D65 = CalRGBCS.#tempNormalizeMatrix;
2559    this.#toD65(sourceWhitePoint, LMS, LMS_D65);
2560    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
2561  }
2562  #toRgb(src, srcOffset, dest, destOffset, scale) {
2563    const A = MathClamp(src[srcOffset] * scale, 0, 1);
2564    const B = MathClamp(src[srcOffset + 1] * scale, 0, 1);
2565    const C = MathClamp(src[srcOffset + 2] * scale, 0, 1);
2566    const AGR = A === 1 ? 1 : A ** this.GR;
2567    const BGG = B === 1 ? 1 : B ** this.GG;
2568    const CGB = C === 1 ? 1 : C ** this.GB;
2569    const X = this.MXA * AGR + this.MXB * BGG + this.MXC * CGB;
2570    const Y = this.MYA * AGR + this.MYB * BGG + this.MYC * CGB;
2571    const Z = this.MZA * AGR + this.MZB * BGG + this.MZC * CGB;
2572    const XYZ = CalRGBCS.#tempConvertMatrix1;
2573    XYZ[0] = X;
2574    XYZ[1] = Y;
2575    XYZ[2] = Z;
2576    const XYZ_Flat = CalRGBCS.#tempConvertMatrix2;
2577    this.#normalizeWhitePointToFlat(this.whitePoint, XYZ, XYZ_Flat);
2578    const XYZ_Black = CalRGBCS.#tempConvertMatrix1;
2579    this.#compensateBlackPoint(this.blackPoint, XYZ_Flat, XYZ_Black);
2580    const XYZ_D65 = CalRGBCS.#tempConvertMatrix2;
2581    this.#normalizeWhitePointToD65(CalRGBCS.#FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);
2582    const SRGB = CalRGBCS.#tempConvertMatrix1;
2583    this.#matrixProduct(CalRGBCS.#SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
2584    dest[destOffset] = this.#sRGBTransferFunction(SRGB[0]) * 255;
2585    dest[destOffset + 1] = this.#sRGBTransferFunction(SRGB[1]) * 255;
2586    dest[destOffset + 2] = this.#sRGBTransferFunction(SRGB[2]) * 255;
2587  }
2588  getRgbItem(src, srcOffset, dest, destOffset) {
2589    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2590  }
2591  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2592    const scale = 1 / ((1 << bits) - 1);
2593    for (let i = 0; i < count; ++i) {
2594      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2595      srcOffset += 3;
2596      destOffset += 3 + alpha01;
2597    }
2598  }
2599  getOutputLength(inputLength, alpha01) {
2600    return inputLength * (3 + alpha01) / 3 | 0;
2601  }
2602}
2603class LabCS extends ColorSpace {
2604  constructor(whitePoint, blackPoint, range) {
2605    super("Lab", 3);
2606    if (!whitePoint) {
2607      throw new FormatError("WhitePoint missing - required for color space Lab");
2608    }
2609    [this.XW, this.YW, this.ZW] = whitePoint;
2610    [this.amin, this.amax, this.bmin, this.bmax] = range || [-100, 100, -100, 100];
2611    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2612    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2613      throw new FormatError("Invalid WhitePoint components, no fallback available");
2614    }
2615    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2616      info("Invalid BlackPoint, falling back to default");
2617      this.XB = this.YB = this.ZB = 0;
2618    }
2619    if (this.amin > this.amax || this.bmin > this.bmax) {
2620      info("Invalid Range, falling back to defaults");
2621      this.amin = -100;
2622      this.amax = 100;
2623      this.bmin = -100;
2624      this.bmax = 100;
2625    }
2626  }
2627  #fn_g(x) {
2628    return x >= 6 / 29 ? x ** 3 : 108 / 841 * (x - 4 / 29);
2629  }
2630  #decode(value, high1, low2, high2) {
2631    return low2 + value * (high2 - low2) / high1;
2632  }
2633  #toRgb(src, srcOffset, maxVal, dest, destOffset) {
2634    let Ls = src[srcOffset];
2635    let as = src[srcOffset + 1];
2636    let bs = src[srcOffset + 2];
2637    if (maxVal !== false) {
2638      Ls = this.#decode(Ls, maxVal, 0, 100);
2639      as = this.#decode(as, maxVal, this.amin, this.amax);
2640      bs = this.#decode(bs, maxVal, this.bmin, this.bmax);
2641    }
2642    if (as > this.amax) {
2643      as = this.amax;
2644    } else if (as < this.amin) {
2645      as = this.amin;
2646    }
2647    if (bs > this.bmax) {
2648      bs = this.bmax;
2649    } else if (bs < this.bmin) {
2650      bs = this.bmin;
2651    }
2652    const M = (Ls + 16) / 116;
2653    const L = M + as / 500;
2654    const N = M - bs / 200;
2655    const X = this.XW * this.#fn_g(L);
2656    const Y = this.YW * this.#fn_g(M);
2657    const Z = this.ZW * this.#fn_g(N);
2658    let r, g, b;
2659    if (this.ZW < 1) {
2660      r = X * 3.1339 + Y * -1.617 + Z * -0.4906;
2661      g = X * -0.9785 + Y * 1.916 + Z * 0.0333;
2662      b = X * 0.072 + Y * -0.229 + Z * 1.4057;
2663    } else {
2664      r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
2665      g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
2666      b = X * 0.0557 + Y * -0.204 + Z * 1.057;
2667    }
2668    dest[destOffset] = Math.sqrt(r) * 255;
2669    dest[destOffset + 1] = Math.sqrt(g) * 255;
2670    dest[destOffset + 2] = Math.sqrt(b) * 255;
2671  }
2672  getRgbItem(src, srcOffset, dest, destOffset) {
2673    this.#toRgb(src, srcOffset, false, dest, destOffset);
2674  }
2675  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2676    const maxVal = (1 << bits) - 1;
2677    for (let i = 0; i < count; i++) {
2678      this.#toRgb(src, srcOffset, maxVal, dest, destOffset);
2679      srcOffset += 3;
2680      destOffset += 3 + alpha01;
2681    }
2682  }
2683  getOutputLength(inputLength, alpha01) {
2684    return inputLength * (3 + alpha01) / 3 | 0;
2685  }
2686  isDefaultDecode(decodeMap, bpc) {
2687    return true;
2688  }
2689  get usesZeroToOneRange() {
2690    return shadow(this, "usesZeroToOneRange", false);
2691  }
2692}
2693
2694;// ./src/core/icc_colorspace.js
2695
2696
2697
2698