https://odoo.pantalytics.com/web/static/lib/pdfjs/build/pdf.worker.js

1/**
2 * @licstart The following is the entire license notice for the
3 * JavaScript code in this page
4 *
5 * Copyright 2024 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * JavaScript code in this page
21 */
22
23/******/ // The require scope
24/******/ var __webpack_require__ = {};
25/******/ 
26/************************************************************************/
27/******/ /* webpack/runtime/define property getters */
28/******/ (() => {
29/******/ 	// define getter functions for harmony exports
30/******/ 	__webpack_require__.d = (exports, definition) => {
31/******/ 		for(var key in definition) {
32/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
33/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
34/******/ 			}
35/******/ 		}
36/******/ 	};
37/******/ })();
38/******/ 
39/******/ /* webpack/runtime/hasOwnProperty shorthand */
40/******/ (() => {
41/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
42/******/ })();
43/******/ 
44/************************************************************************/
45var __webpack_exports__ = globalThis.pdfjsWorker = {};
46
47// EXPORTS
48__webpack_require__.d(__webpack_exports__, {
49  WorkerMessageHandler: () => (/* reexport */ WorkerMessageHandler)
50});
51
52;// ./src/shared/util.js
53const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
54const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
55const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
56const MAX_IMAGE_SIZE_TO_CACHE = 10e6;
57const LINE_FACTOR = 1.35;
58const LINE_DESCENT_FACTOR = 0.35;
59const BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
60const RenderingIntentFlag = {
61  ANY: 0x01,
62  DISPLAY: 0x02,
63  PRINT: 0x04,
64  SAVE: 0x08,
65  ANNOTATIONS_FORMS: 0x10,
66  ANNOTATIONS_STORAGE: 0x20,
67  ANNOTATIONS_DISABLE: 0x40,
68  IS_EDITING: 0x80,
69  OPLIST: 0x100
70};
71const AnnotationMode = {
72  DISABLE: 0,
73  ENABLE: 1,
74  ENABLE_FORMS: 2,
75  ENABLE_STORAGE: 3
76};
77const AnnotationEditorPrefix = "pdfjs_internal_editor_";
78const AnnotationEditorType = {
79  DISABLE: -1,
80  NONE: 0,
81  FREETEXT: 3,
82  HIGHLIGHT: 9,
83  STAMP: 13,
84  INK: 15
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_DEFAULT_COLOR: 32,
97  HIGHLIGHT_THICKNESS: 33,
98  HIGHLIGHT_FREE: 34,
99  HIGHLIGHT_SHOW_ALL: 35
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,

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};
324const PasswordResponses = {
325  NEED_PASSWORD: 1,
326  INCORRECT_PASSWORD: 2
327};
328let verbosity = VerbosityLevel.WARNINGS;
329function setVerbosityLevel(level) {
330  if (Number.isInteger(level)) {
331    verbosity = level;
332  }
333}
334function getVerbosityLevel() {
335  return verbosity;
336}
337function info(msg) {
338  if (verbosity >= VerbosityLevel.INFOS) {
339    console.log(`Info: ${msg}`);
340  }
341}
342function warn(msg) {
343  if (verbosity >= VerbosityLevel.WARNINGS) {
344    console.log(`Warning: ${msg}`);
345  }
346}
347function unreachable(msg) {
348  throw new Error(msg);
349}
350function assert(cond, msg) {
351  if (!cond) {
352    unreachable(msg);
353  }
354}
355function _isValidProtocol(url) {
356  switch (url?.protocol) {
357    case "http:":
358    case "https:":
359    case "ftp:":
360    case "mailto:":
361    case "tel:":
362      return true;
363    default:
364      return false;
365  }
366}
367function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
368  if (!url) {
369    return null;
370  }
371  try {
372    if (options && typeof url === "string") {
373      if (options.addDefaultProtocol && url.startsWith("www.")) {
374        const dots = url.match(/\./g);
375        if (dots?.length >= 2) {
376          url = `http://${url}`;
377        }
378      }
379      if (options.tryConvertEncoding) {
380        try {
381          url = stringToUTF8String(url);
382        } catch {}
383      }
384    }
385    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
386    if (_isValidProtocol(absoluteUrl)) {
387      return absoluteUrl;
388    }
389  } catch {}
390  return null;
391}
392function shadow(obj, prop, value, nonSerializable = false) {
393  Object.defineProperty(obj, prop, {
394    value,
395    enumerable: !nonSerializable,
396    configurable: true,
397    writable: false
398  });
399  return value;
400}
401const BaseException = function BaseExceptionClosure() {
402  function BaseException(message, name) {
403    this.message = message;
404    this.name = name;
405  }
406  BaseException.prototype = new Error();
407  BaseException.constructor = BaseException;
408  return BaseException;
409}();
410class PasswordException extends BaseException {
411  constructor(msg, code) {
412    super(msg, "PasswordException");
413    this.code = code;
414  }
415}
416class UnknownErrorException extends BaseException {
417  constructor(msg, details) {
418    super(msg, "UnknownErrorException");
419    this.details = details;
420  }
421}
422class InvalidPDFException extends BaseException {
423  constructor(msg) {
424    super(msg, "InvalidPDFException");
425  }
426}
427class MissingPDFException extends BaseException {
428  constructor(msg) {
429    super(msg, "MissingPDFException");
430  }
431}
432class UnexpectedResponseException extends BaseException {
433  constructor(msg, status) {
434    super(msg, "UnexpectedResponseException");
435    this.status = status;
436  }
437}
438class FormatError extends BaseException {
439  constructor(msg) {
440    super(msg, "FormatError");
441  }
442}
443class AbortException extends BaseException {
444  constructor(msg) {
445    super(msg, "AbortException");
446  }
447}
448function bytesToString(bytes) {
449  if (typeof bytes !== "object" || bytes?.length === undefined) {
450    unreachable("Invalid argument for bytesToString");
451  }
452  const length = bytes.length;
453  const MAX_ARGUMENT_COUNT = 8192;
454  if (length < MAX_ARGUMENT_COUNT) {
455    return String.fromCharCode.apply(null, bytes);
456  }
457  const strBuf = [];
458  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
459    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
460    const chunk = bytes.subarray(i, chunkEnd);
461    strBuf.push(String.fromCharCode.apply(null, chunk));
462  }
463  return strBuf.join("");
464}
465function stringToBytes(str) {
466  if (typeof str !== "string") {
467    unreachable("Invalid argument for stringToBytes");
468  }
469  const length = str.length;
470  const bytes = new Uint8Array(length);
471  for (let i = 0; i < length; ++i) {
472    bytes[i] = str.charCodeAt(i) & 0xff;

704      try {
705        const decoder = new TextDecoder(encoding, {
706          fatal: true
707        });
708        const buffer = stringToBytes(str);
709        const decoded = decoder.decode(buffer);
710        if (!decoded.includes("\x1b")) {
711          return decoded;
712        }
713        return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
714      } catch (ex) {
715        warn(`stringToPDFString: "${ex}".`);
716      }
717    }
718  }
719  const strBuf = [];
720  for (let i = 0, ii = str.length; i < ii; i++) {
721    const charCode = str.charCodeAt(i);
722    if (charCode === 0x1b) {
723      while (++i < ii && str.charCodeAt(i) !== 0x1b) {}
724      continue;
725    }
726    const code = PDFStringTranslateTable[charCode];
727    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
728  }
729  return strBuf.join("");
730}
731function stringToUTF8String(str) {
732  return decodeURIComponent(escape(str));
733}
734function utf8StringToString(str) {
735  return unescape(encodeURIComponent(str));
736}
737function isArrayEqual(arr1, arr2) {
738  if (arr1.length !== arr2.length) {
739    return false;
740  }
741  for (let i = 0, ii = arr1.length; i < ii; i++) {
742    if (arr1[i] !== arr2[i]) {
743      return false;
744    }
745  }
746  return true;
747}
748function getModificationDate(date = new Date()) {
749  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")];
750  return buffer.join("");
751}
752let NormalizeRegex = null;
753let NormalizationMap = null;
754function normalizeUnicode(str) {
755  if (!NormalizeRegex) {
756    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;
757    NormalizationMap = new Map([["ſt", "ſt"]]);
758  }
759  return str.replaceAll(NormalizeRegex, (_, p1, p2) => p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2));
760}
761function getUuid() {
762  if (typeof crypto !== "undefined" && typeof crypto?.randomUUID === "function") {
763    return crypto.randomUUID();
764  }
765  const buf = new Uint8Array(32);
766  if (typeof crypto !== "undefined" && typeof crypto?.getRandomValues === "function") {
767    crypto.getRandomValues(buf);
768  } else {
769    for (let i = 0; i < 32; i++) {
770      buf[i] = Math.floor(Math.random() * 255);
771    }
772  }
773  return bytesToString(buf);
774}
775const AnnotationPrefix = "pdfjs_internal_id_";
776const FontRenderOps = {
777  BEZIER_CURVE_TO: 0,
778  MOVE_TO: 1,
779  LINE_TO: 2,
780  QUADRATIC_CURVE_TO: 3,
781  RESTORE: 4,
782  SAVE: 5,
783  SCALE: 6,
784  TRANSFORM: 7,
785  TRANSLATE: 8
786};
787function toHexUtil(arr) {
788  if (Uint8Array.prototype.toHex) {
789    return arr.toHex();
790  }
791  return Array.from(arr, num => hexNumbers[num]).join("");
792}
793function toBase64Util(arr) {
794  if (Uint8Array.prototype.toBase64) {
795    return arr.toBase64();
796  }
797  return btoa(bytesToString(arr));
798}
799function fromBase64Util(str) {
800  if (Uint8Array.fromBase64) {
801    return Uint8Array.fromBase64(str);
802  }
803  return stringToBytes(atob(str));
804}
805
806;// ./src/core/primitives.js
807
808const CIRCULAR_REF = Symbol("CIRCULAR_REF");
809const EOF = Symbol("EOF");
810let CmdCache = Object.create(null);
811let NameCache = Object.create(null);
812let RefCache = Object.create(null);
813function clearPrimitiveCaches() {
814  CmdCache = Object.create(null);
815  NameCache = Object.create(null);
816  RefCache = Object.create(null);
817}
818class Name {
819  constructor(name) {
820    this.name = name;
821  }
822  static get(name) {
823    return NameCache[name] ||= new Name(name);
824  }
825}
826class Cmd {
827  constructor(cmd) {
828    this.cmd = cmd;
829  }
830  static get(cmd) {
831    return CmdCache[cmd] ||= new Cmd(cmd);
832  }
833}
834const nonSerializable = function nonSerializableClosure() {
835  return nonSerializable;
836};
837class Dict {
838  constructor(xref = null) {
839    this._map = Object.create(null);
840    this.xref = xref;
841    this.objId = null;
842    this.suppressEncryption = false;

843    this.__nonSerializable__ = nonSerializable;
844  }
845  assignXref(newXref) {
846    this.xref = newXref;
847  }
848  get size() {
849    return Object.keys(this._map).length;
850  }
851  get(key1, key2, key3) {
852    let value = this._map[key1];
853    if (value === undefined && key2 !== undefined) {
854      value = this._map[key2];
855      if (value === undefined && key3 !== undefined) {
856        value = this._map[key3];
857      }
858    }
859    if (value instanceof Ref && this.xref) {
860      return this.xref.fetch(value, this.suppressEncryption);
861    }
862    return value;
863  }
864  async getAsync(key1, key2, key3) {
865    let value = this._map[key1];
866    if (value === undefined && key2 !== undefined) {
867      value = this._map[key2];
868      if (value === undefined && key3 !== undefined) {
869        value = this._map[key3];
870      }
871    }
872    if (value instanceof Ref && this.xref) {
873      return this.xref.fetchAsync(value, this.suppressEncryption);
874    }
875    return value;
876  }
877  getArray(key1, key2, key3) {
878    let value = this._map[key1];
879    if (value === undefined && key2 !== undefined) {
880      value = this._map[key2];
881      if (value === undefined && key3 !== undefined) {
882        value = this._map[key3];
883      }
884    }
885    if (value instanceof Ref && this.xref) {
886      value = this.xref.fetch(value, this.suppressEncryption);
887    }
888    if (Array.isArray(value)) {
889      value = value.slice();
890      for (let i = 0, ii = value.length; i < ii; i++) {
891        if (value[i] instanceof Ref && this.xref) {
892          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
893        }
894      }
895    }
896    return value;
897  }
898  getRaw(key) {
899    return this._map[key];
900  }
901  getKeys() {
902    return Object.keys(this._map);
903  }
904  getRawValues() {
905    return Object.values(this._map);
906  }
907  set(key, value) {
908    this._map[key] = value;
909  }
910  has(key) {
911    return this._map[key] !== undefined;
912  }
913  forEach(callback) {
914    for (const key in this._map) {
915      callback(key, this.get(key));
916    }
917  }
918  static get empty() {
919    const emptyDict = new Dict(null);
920    emptyDict.set = (key, value) => {
921      unreachable("Should not call `set` on the empty dictionary.");
922    };
923    return shadow(this, "empty", emptyDict);
924  }
925  static merge({
926    xref,
927    dictArray,
928    mergeSubDicts = false
929  }) {
930    const mergedDict = new Dict(xref),
931      properties = new Map();
932    for (const dict of dictArray) {
933      if (!(dict instanceof Dict)) {
934        continue;
935      }
936      for (const [key, value] of Object.entries(dict._map)) {
937        let property = properties.get(key);
938        if (property === undefined) {
939          property = [];
940          properties.set(key, property);
941        } else if (!mergeSubDicts || !(value instanceof Dict)) {
942          continue;
943        }
944        property.push(value);
945      }
946    }
947    for (const [name, values] of properties) {
948      if (values.length === 1 || !(values[0] instanceof Dict)) {
949        mergedDict._map[name] = values[0];
950        continue;
951      }
952      const subDict = new Dict(xref);
953      for (const dict of values) {
954        for (const [key, value] of Object.entries(dict._map)) {
955          if (subDict._map[key] === undefined) {
956            subDict._map[key] = value;
957          }
958        }
959      }
960      if (subDict.size > 0) {
961        mergedDict._map[name] = subDict;
962      }
963    }
964    properties.clear();
965    return mergedDict.size > 0 ? mergedDict : Dict.empty;
966  }
967  clone() {
968    const dict = new Dict(this.xref);
969    for (const key of this.getKeys()) {
970      dict.set(key, this.getRaw(key));
971    }
972    return dict;
973  }
974  delete(key) {
975    delete this._map[key];
976  }
977}
978class Ref {
979  constructor(num, gen) {
980    this.num = num;
981    this.gen = gen;
982  }
983  toString() {
984    if (this.gen === 0) {
985      return `${this.num}R`;
986    }
987    return `${this.num}R${this.gen}`;
988  }
989  static fromString(str) {
990    const ref = RefCache[str];
991    if (ref) {
992      return ref;
993    }
994    const m = /^(\d+)R(\d*)$/.exec(str);
995    if (!m || m[1] === "0") {
996      return null;
997    }
998    return RefCache[str] = new Ref(parseInt(m[1]), !m[2] ? 0 : parseInt(m[2]));
999  }
1000  static get(num, gen) {

1001    const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
1002    return RefCache[key] ||= new Ref(num, gen);
1003  }
1004}
1005class RefSet {
1006  constructor(parent = null) {
1007    this._set = new Set(parent?._set);
1008  }
1009  has(ref) {
1010    return this._set.has(ref.toString());
1011  }
1012  put(ref) {
1013    this._set.add(ref.toString());
1014  }
1015  remove(ref) {
1016    this._set.delete(ref.toString());
1017  }
1018  [Symbol.iterator]() {
1019    return this._set.values();
1020  }
1021  clear() {
1022    this._set.clear();
1023  }
1024}
1025class RefSetCache {
1026  constructor() {
1027    this._map = new Map();
1028  }
1029  get size() {
1030    return this._map.size;
1031  }
1032  get(ref) {
1033    return this._map.get(ref.toString());
1034  }
1035  has(ref) {
1036    return this._map.has(ref.toString());
1037  }
1038  put(ref, obj) {
1039    this._map.set(ref.toString(), obj);
1040  }
1041  putAlias(ref, aliasRef) {
1042    this._map.set(ref.toString(), this.get(aliasRef));
1043  }
1044  [Symbol.iterator]() {
1045    return this._map.values();
1046  }
1047  clear() {
1048    this._map.clear();
1049  }
1050  *items() {
1051    for (const [ref, value] of this._map) {
1052      yield [Ref.fromString(ref), value];
1053    }
1054  }
1055}
1056function isName(v, name) {
1057  return v instanceof Name && (name === undefined || v.name === name);
1058}
1059function isCmd(v, cmd) {
1060  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
1061}
1062function isDict(v, type) {
1063  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
1064}
1065function isRefsEqual(v1, v2) {
1066  return v1.num === v2.num && v1.gen === v2.gen;
1067}
1068
1069;// ./src/core/base_stream.js
1070
1071class BaseStream {
1072  get length() {
1073    unreachable("Abstract getter `length` accessed");
1074  }
1075  get isEmpty() {
1076    unreachable("Abstract getter `isEmpty` accessed");
1077  }
1078  get isDataLoaded() {
1079    return shadow(this, "isDataLoaded", true);
1080  }
1081  getByte() {
1082    unreachable("Abstract method `getByte` called");
1083  }
1084  getBytes(length) {
1085    unreachable("Abstract method `getBytes` called");
1086  }
1087  async getImageData(length, decoderOptions) {
1088    return this.getBytes(length, decoderOptions);
1089  }
1090  async asyncGetBytes() {
1091    unreachable("Abstract method `asyncGetBytes` called");
1092  }
1093  get isAsync() {
1094    return false;
1095  }
1096  get canAsyncDecodeImageFromBuffer() {
1097    return false;
1098  }
1099  async getTransferableImage() {
1100    return null;
1101  }
1102  peekByte() {
1103    const peekedByte = this.getByte();
1104    if (peekedByte !== -1) {
1105      this.pos--;
1106    }
1107    return peekedByte;
1108  }
1109  peekBytes(length) {
1110    const bytes = this.getBytes(length);
1111    this.pos -= bytes.length;
1112    return bytes;
1113  }
1114  getUint16() {
1115    const b0 = this.getByte();
1116    const b1 = this.getByte();
1117    if (b0 === -1 || b1 === -1) {
1118      return -1;
1119    }
1120    return (b0 << 8) + b1;
1121  }
1122  getInt32() {
1123    const b0 = this.getByte();
1124    const b1 = this.getByte();
1125    const b2 = this.getByte();
1126    const b3 = this.getByte();
1127    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1128  }
1129  getByteRange(begin, end) {
1130    unreachable("Abstract method `getByteRange` called");
1131  }
1132  getString(length) {
1133    return bytesToString(this.getBytes(length));
1134  }
1135  skip(n) {
1136    this.pos += n || 1;
1137  }
1138  reset() {
1139    unreachable("Abstract method `reset` called");
1140  }
1141  moveStart() {
1142    unreachable("Abstract method `moveStart` called");
1143  }
1144  makeSubStream(start, length, dict = null) {
1145    unreachable("Abstract method `makeSubStream` called");
1146  }
1147  getBaseStreams() {
1148    return null;
1149  }
1150}
1151
1152;// ./src/core/core_utils.js
1153
1154
1155
1156const PDF_VERSION_REGEXP = /^[1-9]\.\d$/;
1157function getLookupTableFactory(initializer) {
1158  let lookup;
1159  return function () {
1160    if (initializer) {
1161      lookup = Object.create(null);
1162      initializer(lookup);
1163      initializer = null;
1164    }
1165    return lookup;
1166  };
1167}
1168class MissingDataException extends BaseException {
1169  constructor(begin, end) {
1170    super(`Missing data [${begin}, ${end})`, "MissingDataException");
1171    this.begin = begin;
1172    this.end = end;
1173  }
1174}
1175class ParserEOFException extends BaseException {
1176  constructor(msg) {
1177    super(msg, "ParserEOFException");
1178  }
1179}
1180class XRefEntryException extends BaseException {
1181  constructor(msg) {
1182    super(msg, "XRefEntryException");
1183  }
1184}
1185class XRefParseException extends BaseException {
1186  constructor(msg) {
1187    super(msg, "XRefParseException");
1188  }
1189}
1190function arrayBuffersToBytes(arr) {
1191  const length = arr.length;
1192  if (length === 0) {
1193    return new Uint8Array(0);
1194  }
1195  if (length === 1) {
1196    return new Uint8Array(arr[0]);
1197  }
1198  let dataLength = 0;
1199  for (let i = 0; i < length; i++) {
1200    dataLength += arr[i].byteLength;
1201  }
1202  const data = new Uint8Array(dataLength);
1203  let pos = 0;
1204  for (let i = 0; i < length; i++) {
1205    const item = new Uint8Array(arr[i]);
1206    data.set(item, pos);
1207    pos += item.byteLength;
1208  }
1209  return data;
1210}
1211function getInheritableProperty({
1212  dict,
1213  key,
1214  getArray = false,
1215  stopWhenFound = true
1216}) {
1217  let values;
1218  const visited = new RefSet();
1219  while (dict instanceof Dict && !(dict.objId && visited.has(dict.objId))) {
1220    if (dict.objId) {
1221      visited.put(dict.objId);
1222    }
1223    const value = getArray ? dict.getArray(key) : dict.get(key);
1224    if (value !== undefined) {
1225      if (stopWhenFound) {
1226        return value;
1227      }
1228      (values ||= []).push(value);
1229    }
1230    dict = dict.get("Parent");
1231  }
1232  return values;
1233}
1234const 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"];
1235function toRomanNumerals(number, lowerCase = false) {
1236  assert(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
1237  const romanBuf = [];
1238  let pos;
1239  while (number >= 1000) {
1240    number -= 1000;
1241    romanBuf.push("M");
1242  }
1243  pos = number / 100 | 0;
1244  number %= 100;
1245  romanBuf.push(ROMAN_NUMBER_MAP[pos]);
1246  pos = number / 10 | 0;
1247  number %= 10;
1248  romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
1249  romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
1250  const romanStr = romanBuf.join("");
1251  return lowerCase ? romanStr.toLowerCase() : romanStr;
1252}
1253function log2(x) {
1254  if (x <= 0) {
1255    return 0;
1256  }
1257  return Math.ceil(Math.log2(x));
1258}
1259function readInt8(data, offset) {
1260  return data[offset] << 24 >> 24;
1261}
1262function readUint16(data, offset) {
1263  return data[offset] << 8 | data[offset + 1];
1264}
1265function readUint32(data, offset) {
1266  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
1267}
1268function isWhiteSpace(ch) {
1269  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
1270}
1271function isBooleanArray(arr, len) {
1272  return Array.isArray(arr) && (len === null || arr.length === len) && arr.every(x => typeof x === "boolean");
1273}
1274function isNumberArray(arr, len) {
1275  if (Array.isArray(arr)) {
1276    return (len === null || arr.length === len) && arr.every(x => typeof x === "number");
1277  }
1278  return ArrayBuffer.isView(arr) && (arr.length === 0 || typeof arr[0] === "number") && (len === null || arr.length === len);
1279}
1280function lookupMatrix(arr, fallback) {
1281  return isNumberArray(arr, 6) ? arr : fallback;
1282}
1283function lookupRect(arr, fallback) {
1284  return isNumberArray(arr, 4) ? arr : fallback;
1285}
1286function lookupNormalRect(arr, fallback) {
1287  return isNumberArray(arr, 4) ? Util.normalizeRect(arr) : fallback;
1288}
1289function parseXFAPath(path) {
1290  const positionPattern = /(.+)\[(\d+)\]$/;
1291  return path.split(".").map(component => {
1292    const m = component.match(positionPattern);
1293    if (m) {
1294      return {
1295        name: m[1],
1296        pos: parseInt(m[2], 10)
1297      };
1298    }
1299    return {
1300      name: component,
1301      pos: 0
1302    };
1303  });
1304}
1305function escapePDFName(str) {
1306  const buffer = [];
1307  let start = 0;
1308  for (let i = 0, ii = str.length; i < ii; i++) {
1309    const char = str.charCodeAt(i);
1310    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) {
1311      if (start < i) {
1312        buffer.push(str.substring(start, i));
1313      }
1314      buffer.push(`#${char.toString(16)}`);
1315      start = i + 1;
1316    }
1317  }
1318  if (buffer.length === 0) {
1319    return str;
1320  }
1321  if (start < str.length) {
1322    buffer.push(str.substring(start, str.length));
1323  }
1324  return buffer.join("");
1325}
1326function escapeString(str) {
1327  return str.replaceAll(/([()\\\n\r])/g, match => {
1328    if (match === "\n") {
1329      return "\\n";
1330    } else if (match === "\r") {
1331      return "\\r";
1332    }
1333    return `\\${match}`;
1334  });
1335}
1336function _collectJS(entry, xref, list, parents) {
1337  if (!entry) {
1338    return;
1339  }
1340  let parent = null;
1341  if (entry instanceof Ref) {
1342    if (parents.has(entry)) {
1343      return;
1344    }
1345    parent = entry;
1346    parents.put(parent);
1347    entry = xref.fetch(entry);
1348  }
1349  if (Array.isArray(entry)) {
1350    for (const element of entry) {
1351      _collectJS(element, xref, list, parents);
1352    }
1353  } else if (entry instanceof Dict) {
1354    if (isName(entry.get("S"), "JavaScript")) {
1355      const js = entry.get("JS");
1356      let code;
1357      if (js instanceof BaseStream) {
1358        code = js.getString();
1359      } else if (typeof js === "string") {
1360        code = js;
1361      }
1362      code &&= stringToPDFString(code).replaceAll("\x00", "");
1363      if (code) {
1364        list.push(code);
1365      }
1366    }
1367    _collectJS(entry.getRaw("Next"), xref, list, parents);
1368  }
1369  if (parent) {
1370    parents.remove(parent);
1371  }
1372}
1373function collectActions(xref, dict, eventType) {
1374  const actions = Object.create(null);
1375  const additionalActionsDicts = getInheritableProperty({
1376    dict,
1377    key: "AA",
1378    stopWhenFound: false
1379  });
1380  if (additionalActionsDicts) {
1381    for (let i = additionalActionsDicts.length - 1; i >= 0; i--) {
1382      const additionalActions = additionalActionsDicts[i];
1383      if (!(additionalActions instanceof Dict)) {
1384        continue;
1385      }
1386      for (const key of additionalActions.getKeys()) {
1387        const action = eventType[key];
1388        if (!action) {
1389          continue;
1390        }
1391        const actionDict = additionalActions.getRaw(key);
1392        const parents = new RefSet();
1393        const list = [];
1394        _collectJS(actionDict, xref, list, parents);
1395        if (list.length > 0) {
1396          actions[action] = list;
1397        }
1398      }
1399    }
1400  }
1401  if (dict.has("A")) {
1402    const actionDict = dict.get("A");
1403    const parents = new RefSet();
1404    const list = [];
1405    _collectJS(actionDict, xref, list, parents);
1406    if (list.length > 0) {
1407      actions.Action = list;
1408    }
1409  }
1410  return objectSize(actions) > 0 ? actions : null;
1411}
1412const XMLEntities = {
1413  0x3c: "&lt;",
1414  0x3e: "&gt;",
1415  0x26: "&amp;",
1416  0x22: "&quot;",
1417  0x27: "&apos;"
1418};
1419function* codePointIter(str) {
1420  for (let i = 0, ii = str.length; i < ii; i++) {
1421    const char = str.codePointAt(i);
1422    if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1423      i++;
1424    }
1425    yield char;
1426  }
1427}
1428function encodeToXmlString(str) {
1429  const buffer = [];
1430  let start = 0;
1431  for (let i = 0, ii = str.length; i < ii; i++) {
1432    const char = str.codePointAt(i);
1433    if (0x20 <= char && char <= 0x7e) {
1434      const entity = XMLEntities[char];
1435      if (entity) {
1436        if (start < i) {
1437          buffer.push(str.substring(start, i));
1438        }
1439        buffer.push(entity);
1440        start = i + 1;
1441      }
1442    } else {
1443      if (start < i) {
1444        buffer.push(str.substring(start, i));
1445      }
1446      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
1447      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1448        i++;
1449      }
1450      start = i + 1;
1451    }
1452  }
1453  if (buffer.length === 0) {
1454    return str;
1455  }
1456  if (start < str.length) {
1457    buffer.push(str.substring(start, str.length));
1458  }
1459  return buffer.join("");
1460}
1461function validateFontName(fontFamily, mustWarn = false) {
1462  const m = /^("|').*("|')$/.exec(fontFamily);
1463  if (m && m[1] === m[2]) {
1464    const re = new RegExp(`[^\\\\]${m[1]}`);
1465    if (re.test(fontFamily.slice(1, -1))) {
1466      if (mustWarn) {
1467        warn(`FontFamily contains unescaped ${m[1]}: ${fontFamily}.`);
1468      }
1469      return false;
1470    }
1471  } else {
1472    for (const ident of fontFamily.split(/[ \t]+/)) {
1473      if (/^(\d|(-(\d|-)))/.test(ident) || !/^[\w-\\]+$/.test(ident)) {
1474        if (mustWarn) {
1475          warn(`FontFamily contains invalid <custom-ident>: ${fontFamily}.`);
1476        }
1477        return false;
1478      }
1479    }
1480  }
1481  return true;
1482}
1483function validateCSSFont(cssFontInfo) {
1484  const DEFAULT_CSS_FONT_OBLIQUE = "14";
1485  const DEFAULT_CSS_FONT_WEIGHT = "400";
1486  const CSS_FONT_WEIGHT_VALUES = new Set(["100", "200", "300", "400", "500", "600", "700", "800", "900", "1000", "normal", "bold", "bolder", "lighter"]);
1487  const {
1488    fontFamily,
1489    fontWeight,
1490    italicAngle
1491  } = cssFontInfo;
1492  if (!validateFontName(fontFamily, true)) {
1493    return false;
1494  }
1495  const weight = fontWeight ? fontWeight.toString() : "";
1496  cssFontInfo.fontWeight = CSS_FONT_WEIGHT_VALUES.has(weight) ? weight : DEFAULT_CSS_FONT_WEIGHT;
1497  const angle = parseFloat(italicAngle);
1498  cssFontInfo.italicAngle = isNaN(angle) || angle < -90 || angle > 90 ? DEFAULT_CSS_FONT_OBLIQUE : italicAngle.toString();
1499  return true;
1500}
1501function recoverJsURL(str) {
1502  const URL_OPEN_METHODS = ["app.launchURL", "window.open", "xfa.host.gotoURL"];
1503  const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").replaceAll(".", "\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
1504  const jsUrl = regex.exec(str);
1505  if (jsUrl?.[2]) {
1506    const url = jsUrl[2];
1507    let newWindow = false;
1508    if (jsUrl[3] === "true" && jsUrl[1] === "app.launchURL") {
1509      newWindow = true;
1510    }
1511    return {
1512      url,
1513      newWindow
1514    };
1515  }
1516  return null;
1517}
1518function numberToString(value) {
1519  if (Number.isInteger(value)) {
1520    return value.toString();
1521  }
1522  const roundedValue = Math.round(value * 100);
1523  if (roundedValue % 100 === 0) {
1524    return (roundedValue / 100).toString();
1525  }
1526  if (roundedValue % 10 === 0) {
1527    return value.toFixed(1);
1528  }
1529  return value.toFixed(2);
1530}
1531function getNewAnnotationsMap(annotationStorage) {
1532  if (!annotationStorage) {
1533    return null;
1534  }
1535  const newAnnotationsByPage = new Map();
1536  for (const [key, value] of annotationStorage) {
1537    if (!key.startsWith(AnnotationEditorPrefix)) {
1538      continue;
1539    }
1540    let annotations = newAnnotationsByPage.get(value.pageIndex);
1541    if (!annotations) {
1542      annotations = [];
1543      newAnnotationsByPage.set(value.pageIndex, annotations);
1544    }
1545    annotations.push(value);
1546  }
1547  return newAnnotationsByPage.size > 0 ? newAnnotationsByPage : null;
1548}
1549function stringToAsciiOrUTF16BE(str) {
1550  return isAscii(str) ? str : stringToUTF16String(str, true);
1551}
1552function isAscii(str) {
1553  return /^[\x00-\x7F]*$/.test(str);
1554}
1555function stringToUTF16HexString(str) {
1556  const buf = [];
1557  for (let i = 0, ii = str.length; i < ii; i++) {
1558    const char = str.charCodeAt(i);
1559    buf.push(hexNumbers[char >> 8 & 0xff], hexNumbers[char & 0xff]);
1560  }
1561  return buf.join("");
1562}
1563function stringToUTF16String(str, bigEndian = false) {
1564  const buf = [];
1565  if (bigEndian) {
1566    buf.push("\xFE\xFF");
1567  }
1568  for (let i = 0, ii = str.length; i < ii; i++) {
1569    const char = str.charCodeAt(i);
1570    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1571  }
1572  return buf.join("");
1573}
1574function getRotationMatrix(rotation, width, height) {
1575  switch (rotation) {
1576    case 90:
1577      return [0, 1, -1, 0, width, 0];
1578    case 180:
1579      return [-1, 0, 0, -1, width, height];
1580    case 270:
1581      return [0, -1, 1, 0, 0, height];
1582    default:
1583      throw new Error("Invalid rotation");
1584  }
1585}
1586function getSizeInBytes(x) {
1587  return Math.ceil(Math.ceil(Math.log2(1 + x)) / 8);
1588}
1589
1590;// ./src/core/stream.js
1591
1592
1593class Stream extends BaseStream {
1594  constructor(arrayBuffer, start, length, dict) {
1595    super();
1596    this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
1597    this.start = start || 0;
1598    this.pos = this.start;
1599    this.end = start + length || this.bytes.length;
1600    this.dict = dict;
1601  }
1602  get length() {
1603    return this.end - this.start;
1604  }
1605  get isEmpty() {
1606    return this.length === 0;
1607  }
1608  getByte() {
1609    if (this.pos >= this.end) {
1610      return -1;
1611    }
1612    return this.bytes[this.pos++];
1613  }
1614  getBytes(length) {
1615    const bytes = this.bytes;
1616    const pos = this.pos;
1617    const strEnd = this.end;
1618    if (!length) {
1619      return bytes.subarray(pos, strEnd);
1620    }
1621    let end = pos + length;
1622    if (end > strEnd) {
1623      end = strEnd;
1624    }
1625    this.pos = end;
1626    return bytes.subarray(pos, end);
1627  }
1628  getByteRange(begin, end) {
1629    if (begin < 0) {
1630      begin = 0;
1631    }
1632    if (end > this.end) {
1633      end = this.end;
1634    }
1635    return this.bytes.subarray(begin, end);
1636  }
1637  reset() {
1638    this.pos = this.start;
1639  }
1640  moveStart() {
1641    this.start = this.pos;
1642  }
1643  makeSubStream(start, length, dict = null) {
1644    return new Stream(this.bytes.buffer, start, length, dict);
1645  }
1646}
1647class StringStream extends Stream {
1648  constructor(str) {
1649    super(stringToBytes(str));
1650  }
1651}
1652class NullStream extends Stream {
1653  constructor() {
1654    super(new Uint8Array(0));
1655  }
1656}
1657
1658;// ./src/core/chunked_stream.js

1658
1659
1660
1661
1662class ChunkedStream extends Stream {
1663  constructor(length, chunkSize, manager) {
1664    super(new Uint8Array(length), 0, length, null);
1665    this.chunkSize = chunkSize;
1666    this._loadedChunks = new Set();
1667    this.numChunks = Math.ceil(length / chunkSize);
1668    this.manager = manager;
1669    this.progressiveDataLength = 0;
1670    this.lastSuccessfulEnsureByteChunk = -1;
1671  }
1672  getMissingChunks() {
1673    const chunks = [];
1674    for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
1675      if (!this._loadedChunks.has(chunk)) {
1676        chunks.push(chunk);
1677      }
1678    }
1679    return chunks;
1680  }
1681  get numChunksLoaded() {
1682    return this._loadedChunks.size;
1683  }
1684  get isDataLoaded() {
1685    return this.numChunksLoaded === this.numChunks;
1686  }
1687  onReceiveData(begin, chunk) {
1688    const chunkSize = this.chunkSize;
1689    if (begin % chunkSize !== 0) {
1690      throw new Error(`Bad begin offset: ${begin}`);
1691    }
1692    const end = begin + chunk.byteLength;
1693    if (end % chunkSize !== 0 && end !== this.bytes.length) {
1694      throw new Error(`Bad end offset: ${end}`);
1695    }
1696    this.bytes.set(new Uint8Array(chunk), begin);
1697    const beginChunk = Math.floor(begin / chunkSize);
1698    const endChunk = Math.floor((end - 1) / chunkSize) + 1;
1699    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
1700      this._loadedChunks.add(curChunk);
1701    }
1702  }
1703  onReceiveProgressiveData(data) {
1704    let position = this.progressiveDataLength;
1705    const beginChunk = Math.floor(position / this.chunkSize);
1706    this.bytes.set(new Uint8Array(data), position);
1707    position += data.byteLength;
1708    this.progressiveDataLength = position;
1709    const endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
1710    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
1711      this._loadedChunks.add(curChunk);
1712    }
1713  }
1714  ensureByte(pos) {
1715    if (pos < this.progressiveDataLength) {
1716      return;
1717    }
1718    const chunk = Math.floor(pos / this.chunkSize);
1719    if (chunk > this.numChunks) {
1720      return;
1721    }
1722    if (chunk === this.lastSuccessfulEnsureByteChunk) {
1723      return;
1724    }
1725    if (!this._loadedChunks.has(chunk)) {
1726      throw new MissingDataException(pos, pos + 1);
1727    }
1728    this.lastSuccessfulEnsureByteChunk = chunk;
1729  }
1730  ensureRange(begin, end) {
1731    if (begin >= end) {
1732      return;
1733    }
1734    if (end <= this.progressiveDataLength) {
1735      return;
1736    }
1737    const beginChunk = Math.floor(begin / this.chunkSize);
1738    if (beginChunk > this.numChunks) {
1739      return;
1740    }
1741    const endChunk = Math.min(Math.floor((end - 1) / this.chunkSize) + 1, this.numChunks);
1742    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
1743      if (!this._loadedChunks.has(chunk)) {
1744        throw new MissingDataException(begin, end);
1745      }
1746    }
1747  }
1748  nextEmptyChunk(beginChunk) {
1749    const numChunks = this.numChunks;
1750    for (let i = 0; i < numChunks; ++i) {
1751      const chunk = (beginChunk + i) % numChunks;
1752      if (!this._loadedChunks.has(chunk)) {
1753        return chunk;
1754      }
1755    }
1756    return null;
1757  }
1758  hasChunk(chunk) {
1759    return this._loadedChunks.has(chunk);
1760  }
1761  getByte() {
1762    const pos = this.pos;
1763    if (pos >= this.end) {
1764      return -1;
1765    }
1766    if (pos >= this.progressiveDataLength) {
1767      this.ensureByte(pos);
1768    }
1769    return this.bytes[this.pos++];
1770  }
1771  getBytes(length) {
1772    const bytes = this.bytes;
1773    const pos = this.pos;
1774    const strEnd = this.end;
1775    if (!length) {
1776      if (strEnd > this.progressiveDataLength) {
1777        this.ensureRange(pos, strEnd);
1778      }
1779      return bytes.subarray(pos, strEnd);
1780    }
1781    let end = pos + length;
1782    if (end > strEnd) {
1783      end = strEnd;
1784    }
1785    if (end > this.progressiveDataLength) {
1786      this.ensureRange(pos, end);
1787    }
1788    this.pos = end;
1789    return bytes.subarray(pos, end);
1790  }
1791  getByteRange(begin, end) {
1792    if (begin < 0) {
1793      begin = 0;
1794    }
1795    if (end > this.end) {
1796      end = this.end;
1797    }
1798    if (end > this.progressiveDataLength) {
1799      this.ensureRange(begin, end);
1800    }
1801    return this.bytes.subarray(begin, end);
1802  }
1803  makeSubStream(start, length, dict = null) {
1804    if (length) {
1805      if (start + length > this.progressiveDataLength) {
1806        this.ensureRange(start, start + length);
1807      }
1808    } else if (start >= this.progressiveDataLength) {
1809      this.ensureByte(start);
1810    }
1811    function ChunkedStreamSubstream() {}
1812    ChunkedStreamSubstream.prototype = Object.create(this);
1813    ChunkedStreamSubstream.prototype.getMissingChunks = function () {
1814      const chunkSize = this.chunkSize;
1815      const beginChunk = Math.floor(this.start / chunkSize);
1816      const endChunk = Math.floor((this.end - 1) / chunkSize) + 1;
1817      const missingChunks = [];
1818      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
1819        if (!this._loadedChunks.has(chunk)) {
1820          missingChunks.push(chunk);
1821        }
1822      }
1823      return missingChunks;
1824    };
1825    Object.defineProperty(ChunkedStreamSubstream.prototype, "isDataLoaded", {
1826      get() {
1827        if (this.numChunksLoaded === this.numChunks) {
1828          return true;
1829        }
1830        return this.getMissingChunks().length === 0;
1831      },
1832      configurable: true
1833    });
1834    const subStream = new ChunkedStreamSubstream();
1835    subStream.pos = subStream.start = start;
1836    subStream.end = start + length || this.end;
1837    subStream.dict = dict;
1838    return subStream;
1839  }
1840  getBaseStreams() {
1841    return [this];
1842  }
1843}
1844class ChunkedStreamManager {
1845  constructor(pdfNetworkStream, args) {
1846    this.length = args.length;
1847    this.chunkSize = args.rangeChunkSize;
1848    this.stream = new ChunkedStream(this.length, this.chunkSize, this);
1849    this.pdfNetworkStream = pdfNetworkStream;
1850    this.disableAutoFetch = args.disableAutoFetch;
1851    this.msgHandler = args.msgHandler;
1852    this.currRequestId = 0;
1853    this._chunksNeededByRequest = new Map();
1854    this._requestsByChunk = new Map();
1855    this._promisesByRequest = new Map();
1856    this.progressiveDataLength = 0;
1857    this.aborted = false;
1858    this._loadedStreamCapability = Promise.withResolvers();
1859  }
1860  sendRequest(begin, end) {
1861    const rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);
1862    if (!rangeReader.isStreamingSupported) {
1863      rangeReader.onProgress = this.onProgress.bind(this);
1864    }
1865    let chunks = [],
1866      loaded = 0;
1867    return new Promise((resolve, reject) => {
1868      const readChunk = ({
1869        value,
1870        done
1871      }) => {
1872        try {
1873          if (done) {
1874            const chunkData = arrayBuffersToBytes(chunks);
1875            chunks = null;
1876            resolve(chunkData);
1877            return;
1878          }
1879          loaded += value.byteLength;
1880          if (rangeReader.isStreamingSupported) {
1881            this.onProgress({
1882              loaded
1883            });
1884          }
1885          chunks.push(value);
1886          rangeReader.read().then(readChunk, reject);
1887        } catch (e) {
1888          reject(e);
1889        }
1890      };
1891      rangeReader.read().then(readChunk, reject);
1892    }).then(data => {
1893      if (this.aborted) {
1894        return;
1895      }
1896      this.onReceiveData({
1897        chunk: data,
1898        begin
1899      });
1900    });
1901  }
1902  requestAllChunks(noFetch = false) {
1903    if (!noFetch) {
1904      const missingChunks = this.stream.getMissingChunks();
1905      this._requestChunks(missingChunks);
1906    }
1907    return this._loadedStreamCapability.promise;
1908  }
1909  _requestChunks(chunks) {
1910    const requestId = this.currRequestId++;
1911    const chunksNeeded = new Set();
1912    this._chunksNeededByRequest.set(requestId, chunksNeeded);
1913    for (const chunk of chunks) {
1914      if (!this.stream.hasChunk(chunk)) {
1915        chunksNeeded.add(chunk);
1916      }
1917    }
1918    if (chunksNeeded.size === 0) {
1919      return Promise.resolve();
1920    }
1921    const capability = Promise.withResolvers();
1922    this._promisesByRequest.set(requestId, capability);
1923    const chunksToRequest = [];
1924    for (const chunk of chunksNeeded) {
1925      let requestIds = this._requestsByChunk.get(chunk);
1926      if (!requestIds) {
1927        requestIds = [];
1928        this._requestsByChunk.set(chunk, requestIds);
1929        chunksToRequest.push(chunk);
1930      }
1931      requestIds.push(requestId);
1932    }
1933    if (chunksToRequest.length > 0) {
1934      const groupedChunksToRequest = this.groupChunks(chunksToRequest);
1935      for (const groupedChunk of groupedChunksToRequest) {
1936        const begin = groupedChunk.beginChunk * this.chunkSize;
1937        const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
1938        this.sendRequest(begin, end).catch(capability.reject);
1939      }
1940    }
1941    return capability.promise.catch(reason => {
1942      if (this.aborted) {
1943        return;
1944      }
1945      throw reason;
1946    });
1947  }
1948  getStream() {
1949    return this.stream;
1950  }
1951  requestRange(begin, end) {
1952    end = Math.min(end, this.length);
1953    const beginChunk = this.getBeginChunk(begin);
1954    const endChunk = this.getEndChunk(end);
1955    const chunks = [];
1956    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
1957      chunks.push(chunk);
1958    }
1959    return this._requestChunks(chunks);
1960  }
1961  requestRanges(ranges = []) {
1962    const chunksToRequest = [];
1963    for (const range of ranges) {
1964      const beginChunk = this.getBeginChunk(range.begin);
1965      const endChunk = this.getEndChunk(range.end);
1966      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
1967        if (!chunksToRequest.includes(chunk)) {
1968          chunksToRequest.push(chunk);
1969        }
1970      }
1971    }
1972    chunksToRequest.sort(

1972function (a, b) {
1973      return a - b;
1974    });
1975    return this._requestChunks(chunksToRequest);
1976  }
1977  groupChunks(chunks) {
1978    const groupedChunks = [];
1979    let beginChunk = -1;
1980    let prevChunk = -1;
1981    for (let i = 0, ii = chunks.length; i < ii; ++i) {
1982      const chunk = chunks[i];
1983      if (beginChunk < 0) {
1984        beginChunk = chunk;
1985      }
1986      if (prevChunk >= 0 && prevChunk + 1 !== chunk) {
1987        groupedChunks.push({
1988          beginChunk,
1989          endChunk: prevChunk + 1
1990        });
1991        beginChunk = chunk;
1992      }
1993      if (i + 1 === chunks.length) {
1994        groupedChunks.push({
1995          beginChunk,
1996          endChunk: chunk + 1
1997        });
1998      }
1999      prevChunk = chunk;
2000    }
2001    return groupedChunks;
2002  }
2003  onProgress(args) {
2004    this.msgHandler.send("DocProgress", {
2005      loaded: this.stream.numChunksLoaded * this.chunkSize + args.loaded,
2006      total: this.length
2007    });
2008  }
2009  onReceiveData(args) {
2010    const chunk = args.chunk;
2011    const isProgressive = args.begin === undefined;
2012    const begin = isProgressive ? this.progressiveDataLength : args.begin;
2013    const end = begin + chunk.byteLength;
2014    const beginChunk = Math.floor(begin / this.chunkSize);
2015    const endChunk = end < this.length ? Math.floor(end / this.chunkSize) : Math.ceil(end / this.chunkSize);
2016    if (isProgressive) {
2017      this.stream.onReceiveProgressiveData(chunk);
2018      this.progressiveDataLength = end;
2019    } else {
2020      this.stream.onReceiveData(begin, chunk);
2021    }
2022    if (this.stream.isDataLoaded) {
2023      this._loadedStreamCapability.resolve(this.stream);
2024    }
2025    const loadedRequests = [];
2026    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2027      const requestIds = this._requestsByChunk.get(curChunk);
2028      if (!requestIds) {
2029        continue;
2030      }
2031      this._requestsByChunk.delete(curChunk);
2032      for (const requestId of requestIds) {
2033        const chunksNeeded = this._chunksNeededByRequest.get(requestId);
2034        if (chunksNeeded.has(curChunk)) {
2035          chunksNeeded.delete(curChunk);
2036        }
2037        if (chunksNeeded.size > 0) {
2038          continue;
2039        }
2040        loadedRequests.push(requestId);
2041      }
2042    }
2043    if (!this.disableAutoFetch && this._requestsByChunk.size === 0) {
2044      let nextEmptyChunk;
2045      if (this.stream.numChunksLoaded === 1) {
2046        const lastChunk = this.stream.numChunks - 1;
2047        if (!this.stream.hasChunk(lastChunk)) {
2048          nextEmptyChunk = lastChunk;
2049        }
2050      } else {
2051        nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);
2052      }
2053      if (Number.isInteger(nextEmptyChunk)) {
2054        this._requestChunks([nextEmptyChunk]);
2055      }
2056    }
2057    for (const requestId of loadedRequests) {
2058      const capability = this._promisesByRequest.get(requestId);
2059      this._promisesByRequest.delete(requestId);
2060      capability.resolve();
2061    }
2062    this.msgHandler.send("DocProgress", {
2063      loaded: this.stream.numChunksLoaded * this.chunkSize,
2064      total: this.length
2065    });
2066  }
2067  onError(err) {
2068    this._loadedStreamCapability.reject(err);
2069  }
2070  getBeginChunk(begin) {
2071    return Math.floor(begin / this.chunkSize);
2072  }
2073  getEndChunk(end) {
2074    return Math.floor((end - 1) / this.chunkSize) + 1;
2075  }
2076  abort(reason) {
2077    this.aborted = true;
2078    this.pdfNetworkStream?.cancelAllRequests(reason);
2079    for (const capability of this._promisesByRequest.values()) {
2080      capability.reject(reason);
2081    }
2082  }
2083}
2084
2085;// ./src/core/colorspace.js
2086
2087
2088
2089
2090function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
2091  const COMPONENTS = 3;
2092  alpha01 = alpha01 !== 1 ? 0 : alpha01;
2093  const xRatio = w1 / w2;
2094  const yRatio = h1 / h2;
2095  let newIndex = 0,
2096    oldIndex;
2097  const xScaled = new Uint16Array(w2);
2098  const w1Scanline = w1 * COMPONENTS;
2099  for (let i = 0; i < w2; i++) {
2100    xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
2101  }
2102  for (let i = 0; i < h2; i++) {
2103    const py = Math.floor(i * yRatio) * w1Scanline;
2104    for (let j = 0; j < w2; j++) {
2105      oldIndex = py + xScaled[j];
2106      dest[newIndex++] = src[oldIndex++];
2107      dest[newIndex++] = src[oldIndex++];
2108      dest[newIndex++] = src[oldIndex++];
2109      newIndex += alpha01;
2110    }
2111  }
2112}
2113function resizeRgbaImage(src, dest, w1, h1, w2, h2, alpha01) {
2114  const xRatio = w1 / w2;
2115  const yRatio = h1 / h2;
2116  let newIndex = 0;
2117  const xScaled = new Uint16Array(w2);
2118  if (alpha01 === 1) {
2119    for (let i = 0; i < w2; i++) {
2120      xScaled[i] = Math.floor(i * xRatio);
2121    }
2122    const src32 = new Uint32Array(src.buffer);
2123    const dest32 = new Uint32Array(dest.buffer);
2124    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2125    for (let i = 0; i < h2; i++) {
2126      const buf = src32.subarray(Math.floor(i * yRatio) * w1);
2127      for (let j = 0; j < w2; j++) {
2128        dest32[newIndex++] |= buf[xScaled[j]] & rgbMask;
2129      }
2130    }
2131  } else {
2132    const COMPONENTS = 4;
2133    const w1Scanline = w1 * COMPONENTS;
2134    for (let i = 0; i < w2; i++) {
2135      xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
2136    }
2137    for (let i = 0; i < h2; i++) {
2138      const buf = src.subarray(Math.floor(i * yRatio) * w1Scanline);
2139      for (let j = 0; j < w2; j++) {
2140        const oldIndex = xScaled[j];
2141        dest[newIndex++] = buf[oldIndex];
2142        dest[newIndex++] = buf[oldIndex + 1];
2143        dest[newIndex++] = buf[oldIndex + 2];
2144      }
2145    }
2146  }
2147}
2148function copyRgbaImage(src, dest, alpha01) {
2149  if (alpha01 === 1) {
2150    const src32 = new Uint32Array(src.buffer);
2151    const dest32 = new Uint32Array(dest.buffer);
2152    const rgbMask = FeatureTest.isLittleEndian ? 0x00ffffff : 0xffffff00;
2153    for (let i = 0, ii = src32.length; i < ii; i++) {
2154      dest32[i] |= src32[i] & rgbMask;
2155    }
2156  } else {
2157    let j = 0;
2158    for (let i = 0, ii = src.length; i < ii; i += 4) {
2159      dest[j++] = src[i];
2160      dest[j++] = src[i + 1];
2161      dest[j++] = src[i + 2];
2162    }
2163  }
2164}
2165class ColorSpace {
2166  constructor(name, numComps) {
2167    this.name = name;
2168    this.numComps = numComps;
2169  }
2170  getRgb(src, srcOffset) {
2171    const rgb = new Uint8ClampedArray(3);
2172    this.getRgbItem(src, srcOffset, rgb, 0);
2173    return rgb;
2174  }
2175  getRgbItem(src, srcOffset, dest, destOffset) {
2176    unreachable("Should not call ColorSpace.getRgbItem");
2177  }
2178  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2179    unreachable("Should not call ColorSpace.getRgbBuffer");
2180  }
2181  getOutputLength(inputLength, alpha01) {
2182    unreachable("Should not call ColorSpace.getOutputLength");
2183  }
2184  isPassthrough(bits) {
2185    return false;
2186  }
2187  isDefaultDecode(decodeMap, bpc) {
2188    return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
2189  }
2190  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2191    const count = originalWidth * originalHeight;
2192    let rgbBuf = null;
2193    const numComponentColors = 1 << bpc;
2194    const needsResizing = originalHeight !== height || originalWidth !== width;
2195    if (this.isPassthrough(bpc)) {
2196      rgbBuf = comps;
2197    } else if (this.numComps === 1 && count > numComponentColors && this.name !== "DeviceGray" && this.name !== "DeviceRGB") {
2198      const allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : new Uint16Array(numComponentColors);
2199      for (let i = 0; i < numComponentColors; i++) {
2200        allColors[i] = i;
2201      }
2202      const colorMap = new Uint8ClampedArray(numComponentColors * 3);
2203      this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc, 0);
2204      if (!needsResizing) {
2205        let destPos = 0;
2206        for (let i = 0; i < count; ++i) {
2207          const key = comps[i] * 3;
2208          dest[destPos++] = colorMap[key];
2209          dest[destPos++] = colorMap[key + 1];
2210          dest[destPos++] = colorMap[key + 2];
2211          destPos += alpha01;
2212        }
2213      } else {
2214        rgbBuf = new Uint8Array(count * 3);
2215        let rgbPos = 0;
2216        for (let i = 0; i < count; ++i) {

2217          const key = comps[i] * 3;
2218          rgbBuf[rgbPos++] = colorMap[key];
2219          rgbBuf[rgbPos++] = colorMap[key + 1];
2220          rgbBuf[rgbPos++] = colorMap[key + 2];
2221        }
2222      }
2223    } else if (!needsResizing) {
2224      this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, alpha01);
2225    } else {
2226      rgbBuf = new Uint8ClampedArray(count * 3);
2227      this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, 0);
2228    }
2229    if (rgbBuf) {
2230      if (needsResizing) {
2231        resizeRgbImage(rgbBuf, dest, originalWidth, originalHeight, width, height, alpha01);
2232      } else {
2233        let destPos = 0,
2234          rgbPos = 0;
2235        for (let i = 0, ii = width * actualHeight; i < ii; i++) {
2236          dest[destPos++] = rgbBuf[rgbPos++];
2237          dest[destPos++] = rgbBuf[rgbPos++];
2238          dest[destPos++] = rgbBuf[rgbPos++];
2239          destPos += alpha01;
2240        }
2241      }
2242    }
2243  }
2244  get usesZeroToOneRange() {
2245    return shadow(this, "usesZeroToOneRange", true);
2246  }
2247  static _cache(cacheKey, xref, localColorSpaceCache, parsedColorSpace) {
2248    if (!localColorSpaceCache) {
2249      throw new Error('ColorSpace._cache - expected "localColorSpaceCache" argument.');
2250    }
2251    if (!parsedColorSpace) {
2252      throw new Error('ColorSpace._cache - expected "parsedColorSpace" argument.');
2253    }
2254    let csName, csRef;
2255    if (cacheKey instanceof Ref) {
2256      csRef = cacheKey;
2257      cacheKey = xref.fetch(cacheKey);
2258    }
2259    if (cacheKey instanceof Name) {
2260      csName = cacheKey.name;
2261    }
2262    if (csName || csRef) {
2263      localColorSpaceCache.set(csName, csRef, parsedColorSpace);
2264    }
2265  }
2266  static getCached(cacheKey, xref, localColorSpaceCache) {
2267    if (!localColorSpaceCache) {
2268      throw new Error('ColorSpace.getCached - expected "localColorSpaceCache" argument.');
2269    }
2270    if (cacheKey instanceof Ref) {
2271      const localColorSpace = localColorSpaceCache.getByRef(cacheKey);
2272      if (localColorSpace) {
2273        return localColorSpace;
2274      }
2275      try {
2276        cacheKey = xref.fetch(cacheKey);
2277      } catch (ex) {
2278        if (ex instanceof MissingDataException) {
2279          throw ex;
2280        }
2281      }
2282    }
2283    if (cacheKey instanceof Name) {
2284      const localColorSpace = localColorSpaceCache.getByName(cacheKey.name);
2285      if (localColorSpace) {
2286        return localColorSpace;
2287      }
2288    }
2289    return null;
2290  }
2291  static async parseAsync({
2292    cs,
2293    xref,
2294    resources = null,
2295    pdfFunctionFactory,
2296    localColorSpaceCache
2297  }) {
2298    const parsedColorSpace = this._parse(cs, xref, resources, pdfFunctionFactory);
2299    this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
2300    return parsedColorSpace;
2301  }
2302  static parse({
2303    cs,
2304    xref,
2305    resources = null,
2306    pdfFunctionFactory,
2307    localColorSpaceCache
2308  }) {
2309    const cachedColorSpace = this.getCached(cs, xref, localColorSpaceCache);
2310    if (cachedColorSpace) {
2311      return cachedColorSpace;
2312    }
2313    const parsedColorSpace = this._parse(cs, xref, resources, pdfFunctionFactory);
2314    this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
2315    return parsedColorSpace;
2316  }
2317  static _parse(cs, xref, resources = null, pdfFunctionFactory) {
2318    cs = xref.fetchIfRef(cs);
2319    if (cs instanceof Name) {
2320      switch (cs.name) {
2321        case "G":
2322        case "DeviceGray":
2323          return this.singletons.gray;
2324        case "RGB":
2325        case "DeviceRGB":
2326          return this.singletons.rgb;
2327        case "DeviceRGBA":
2328          return this.singletons.rgba;
2329        case "CMYK":
2330        case "DeviceCMYK":
2331          return this.singletons.cmyk;
2332        case "Pattern":
2333          return new PatternCS(null);
2334        default:
2335          if (resources instanceof Dict) {
2336            const colorSpaces = resources.get("ColorSpace");
2337            if (colorSpaces instanceof Dict) {
2338              const resourcesCS = colorSpaces.get(cs.name);
2339              if (resourcesCS) {
2340                if (resourcesCS instanceof Name) {
2341                  return this._parse(resourcesCS, xref, resources, pdfFunctionFactory);
2342                }
2343                cs = resourcesCS;
2344                break;
2345              }
2346            }
2347          }
2348          warn(`Unrecognized ColorSpace: ${cs.name}`);
2349          return this.singletons.gray;
2350      }
2351    }
2352    if (Array.isArray(cs)) {
2353      const mode = xref.fetchIfRef(cs[0]).name;
2354      let params, numComps, baseCS, whitePoint, blackPoint, gamma;
2355      switch (mode) {
2356        case "G":
2357        case "DeviceGray":
2358          return this.singletons.gray;
2359        case "RGB":
2360        case "DeviceRGB":
2361          return this.singletons.rgb;
2362        case "CMYK":
2363        case "DeviceCMYK":
2364          return this.singletons.cmyk;
2365        case "CalGray":
2366          params = xref.fetchIfRef(cs[1]);
2367          whitePoint = params.getArray("WhitePoint");
2368          blackPoint = params.getArray("BlackPoint");
2369          gamma = params.get("Gamma");
2370          return new CalGrayCS(whitePoint, blackPoint, gamma);
2371        case "CalRGB":
2372          params = xref.fetchIfRef(cs[1]);
2373          whitePoint = params.getArray("WhitePoint");
2374          blackPoint = params.getArray("BlackPoint");
2375          gamma = params.getArray("Gamma");
2376          const matrix = params.getArray("Matrix");
2377          return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
2378        case "ICCBased":
2379          const stream = xref.fetchIfRef(cs[1]);
2380          const dict = stream.dict;
2381          numComps = dict.get("N");
2382          const alt = dict.get("Alternate");
2383          if (alt) {
2384            const altCS = this._parse(alt, xref, resources, pdfFunctionFactory);
2385            if (altCS.numComps === numComps) {
2386              return altCS;
2387            }
2388            warn("ICCBased color space: Ignoring incorrect /Alternate entry.");
2389          }
2390          if (numComps === 1) {
2391            return this.singletons.gray;
2392          } else if (numComps === 3) {
2393            return this.singletons.rgb;
2394          } else if (numComps === 4) {
2395            return this.singletons.cmyk;
2396          }
2397          break;
2398        case "Pattern":
2399          baseCS = cs[1] || null;
2400          if (baseCS) {
2401            baseCS = this._parse(baseCS, xref, resources, pdfFunctionFactory);
2402          }
2403          return new PatternCS(baseCS);
2404        case "I":
2405        case "Indexed":
2406          baseCS = this._parse(cs[1], xref, resources, pdfFunctionFactory);
2407          const hiVal = Math.max(0, Math.min(xref.fetchIfRef(cs[2]), 255));
2408          const lookup = xref.fetchIfRef(cs[3]);
2409          return new IndexedCS(baseCS, hiVal, lookup);
2410        case "Separation":
2411        case "DeviceN":
2412          const name = xref.fetchIfRef(cs[1]);
2413          numComps = Array.isArray(name) ? name.length : 1;
2414          baseCS = this._parse(cs[2], xref, resources, pdfFunctionFactory);
2415          const tintFn = pdfFunctionFactory.create(cs[3]);
2416          return new AlternateCS(numComps, baseCS, tintFn);
2417        case "Lab":
2418          params = xref.fetchIfRef(cs[1]);
2419          whitePoint = params.getArray("WhitePoint");
2420          blackPoint = params.getArray("BlackPoint");
2421          const range = params.getArray("Range");

2422          return new LabCS(whitePoint, blackPoint, range);
2423        default:
2424          warn(`Unimplemented ColorSpace object: ${mode}`);
2425          return this.singletons.gray;
2426      }
2427    }
2428    warn(`Unrecognized ColorSpace object: ${cs}`);
2429    return this.singletons.gray;
2430  }
2431  static isDefaultDecode(decode, numComps) {
2432    if (!Array.isArray(decode)) {
2433      return true;
2434    }
2435    if (numComps * 2 !== decode.length) {
2436      warn("The decode map is not the correct length");
2437      return true;
2438    }
2439    for (let i = 0, ii = decode.length; i < ii; i += 2) {
2440      if (decode[i] !== 0 || decode[i + 1] !== 1) {
2441        return false;
2442      }
2443    }
2444    return true;
2445  }
2446  static get singletons() {
2447    return shadow(this, "singletons", {
2448      get gray() {
2449        return shadow(this, "gray", new DeviceGrayCS());
2450      },
2451      get rgb() {
2452        return shadow(this, "rgb", new DeviceRgbCS());
2453      },
2454      get rgba() {
2455        return shadow(this, "rgba", new DeviceRgbaCS());
2456      },
2457      get cmyk() {
2458        return shadow(this, "cmyk", new DeviceCmykCS());
2459      }
2460    });
2461  }
2462}
2463class AlternateCS extends ColorSpace {
2464  constructor(numComps, base, tintFn) {
2465    super("Alternate", numComps);
2466    this.base = base;
2467    this.tintFn = tintFn;
2468    this.tmpBuf = new Float32Array(base.numComps);
2469  }
2470  getRgbItem(src, srcOffset, dest, destOffset) {
2471    const tmpBuf = this.tmpBuf;
2472    this.tintFn(src, srcOffset, tmpBuf, 0);
2473    this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
2474  }
2475  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2476    const tintFn = this.tintFn;
2477    const base = this.base;
2478    const scale = 1 / ((1 << bits) - 1);
2479    const baseNumComps = base.numComps;
2480    const usesZeroToOneRange = base.usesZeroToOneRange;
2481    const isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) && alpha01 === 0;
2482    let pos = isPassthrough ? destOffset : 0;
2483    const baseBuf = isPassthrough ? dest : new Uint8ClampedArray(baseNumComps * count);
2484    const numComps = this.numComps;
2485    const scaled = new Float32Array(numComps);
2486    const tinted = new Float32Array(baseNumComps);
2487    let i, j;
2488    for (i = 0; i < count; i++) {
2489      for (j = 0; j < numComps; j++) {
2490        scaled[j] = src[srcOffset++] * scale;
2491      }
2492      tintFn(scaled, 0, tinted, 0);
2493      if (usesZeroToOneRange) {
2494        for (j = 0; j < baseNumComps; j++) {
2495          baseBuf[pos++] = tinted[j] * 255;
2496        }
2497      } else {
2498        base.getRgbItem(tinted, 0, baseBuf, pos);
2499        pos += baseNumComps;
2500      }
2501    }
2502    if (!isPassthrough) {
2503      base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);
2504    }
2505  }
2506  getOutputLength(inputLength, alpha01) {
2507    return this.base.getOutputLength(inputLength * this.base.numComps / this.numComps, alpha01);
2508  }
2509}
2510class PatternCS extends ColorSpace {
2511  constructor(baseCS) {
2512    super("Pattern", null);
2513    this.base = baseCS;
2514  }
2515  isDefaultDecode(decodeMap, bpc) {
2516    unreachable("Should not call PatternCS.isDefaultDecode");
2517  }
2518}
2519class IndexedCS extends ColorSpace {
2520  constructor(base, highVal, lookup) {
2521    super("Indexed", 1);
2522    this.base = base;
2523    const length = base.numComps * (highVal + 1);
2524    this.lookup = new Uint8Array(length);
2525    if (lookup instanceof BaseStream) {
2526      const bytes = lookup.getBytes(length);
2527      this.lookup.set(bytes);
2528    } else if (typeof lookup === "string") {
2529      for (let i = 0; i < length; ++i) {
2530        this.lookup[i] = lookup.charCodeAt(i) & 0xff;
2531      }
2532    } else {
2533      throw new FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);
2534    }
2535  }
2536  getRgbItem(src, srcOffset, dest, destOffset) {
2537    const numComps = this.base.numComps;
2538    const start = src[srcOffset] * numComps;
2539    this.base.getRgbBuffer(this.lookup, start, 1, dest, destOffset, 8, 0);
2540  }
2541  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2542    const base = this.base;
2543    const numComps = base.numComps;
2544    const outputDelta = base.getOutputLength(numComps, alpha01);
2545    const lookup = this.lookup;
2546    for (let i = 0; i < count; ++i) {
2547      const lookupPos = src[srcOffset++] * numComps;
2548      base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);
2549      destOffset += outputDelta;
2550    }
2551  }
2552  getOutputLength(inputLength, alpha01) {
2553    return this.base.getOutputLength(inputLength * this.base.numComps, alpha01);
2554  }
2555  isDefaultDecode(decodeMap, bpc) {
2556    if (!Array.isArray(decodeMap)) {
2557      return true;
2558    }
2559    if (decodeMap.length !== 2) {
2560      warn("Decode map length is not correct");
2561      return true;
2562    }
2563    if (!Number.isInteger(bpc) || bpc < 1) {
2564      warn("Bits per component is not correct");
2565      return true;
2566    }
2567    return decodeMap[0] === 0 && decodeMap[1] === (1 << bpc) - 1;
2568  }
2569}
2570class DeviceGrayCS extends ColorSpace {
2571  constructor() {
2572    super("DeviceGray", 1);
2573  }
2574  getRgbItem(src, srcOffset, dest, destOffset) {
2575    const c = src[srcOffset] * 255;
2576    dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;
2577  }
2578  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2579    const scale = 255 / ((1 << bits) - 1);
2580    let j = srcOffset,
2581      q = destOffset;
2582    for (let i = 0; i < count; ++i) {
2583      const c = scale * src[j++];
2584      dest[q++] = c;
2585      dest[q++] = c;
2586      dest[q++] = c;
2587      q += alpha01;
2588    }
2589  }
2590  getOutputLength(inputLength, alpha01) {
2591    return inputLength * (3 + alpha01);
2592  }
2593}
2594class DeviceRgbCS extends ColorSpace {
2595  constructor() {
2596    super("DeviceRGB", 3);
2597  }
2598  getRgbItem(src, srcOffset, dest, destOffset) {
2599    dest[destOffset] = src[srcOffset] * 255;
2600    dest[destOffset + 1] = src[srcOffset + 1] * 255;
2601    dest[destOffset + 2] = src[srcOffset + 2] * 255;
2602  }
2603  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2604    if (bits === 8 && alpha01 === 0) {
2605      dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);
2606      return;
2607    }
2608    const scale = 255 / ((1 << bits) - 1);
2609    let j = srcOffset,
2610      q = destOffset;
2611    for (let i = 0; i < count; ++i) {
2612      dest[q++] = scale * src[j++];
2613      dest[q++] = scale * src[j++];
2614      dest[q++] = scale * src[j++];
2615      q += alpha01;
2616    }
2617  }
2618  getOutputLength(inputLength, alpha01) {
2619    return inputLength * (3 + alpha01) / 3 | 0;
2620  }
2621  isPassthrough(bits) {
2622    return bits === 8;
2623  }
2624}
2625class DeviceRgbaCS extends ColorSpace {
2626  constructor() {
2627    super("DeviceRGBA", 4);
2628  }
2629  getOutputLength(inputLength, _alpha01) {
2630    return inputLength * 4;
2631  }
2632  isPassthrough(bits) {
2633    return bits === 8;
2634  }
2635  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
2636    if (originalHeight !== height || originalWidth !== width) {
2637      resizeRgbaImage(comps, dest, originalWidth, originalHeight, width, height, alpha01);
2638    } else {
2639      copyRgbaImage(comps, dest, alpha01);
2640    }
2641  }
2642}
2643class DeviceCmykCS extends ColorSpace {
2644  constructor() {
2645    super("DeviceCMYK", 4);
2646  }
2647  #toRgb(src, srcOffset, srcScale, dest, destOffset) {
2648    const c = src[srcOffset] * srcScale;
2649    const m = src[srcOffset + 1] * srcScale;
2650    const y = src[srcOffset + 2] * srcScale;
2651    const k = src[srcOffset + 3] * srcScale;
2652    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);
2653    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);
2654    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);
2655  }
2656  getRgbItem(src, srcOffset, dest, destOffset) {
2657    this.#toRgb(src, srcOffset, 1, dest, destOffset);
2658  }
2659  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2660    const scale = 1 / ((1 << bits) - 1);
2661    for (let i = 0; i < count; i++) {
2662      this.#toRgb(src, srcOffset, scale, dest, destOffset);
2663      srcOffset += 4;
2664      destOffset += 3 + alpha01;
2665    }
2666  }
2667  getOutputLength(inputLength, alpha01) {
2668    return inputLength / 4 * (3 + alpha01) | 0;
2669  }
2670}
2671class CalGrayCS extends ColorSpace {
2672  constructor(whitePoint, blackPoint, gamma) {
2673    super("CalGray", 1);
2674    if (!whitePoint) {
2675      throw new FormatError("WhitePoint missing - required for color space CalGray");
2676    }
2677    [this.XW, this.YW, this.ZW] = whitePoint;
2678    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2679    this.G = gamma || 1;
2680    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2681      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2682    }
2683    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2684      info(`Invalid BlackPoint for ${this.name}, falling back to default.`);
2685      this.XB = this.YB = this.ZB = 0;
2686    }
2687    if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {
2688      warn(`${this.name}, BlackPoint: XB: ${this.XB}, YB: ${this.YB}, ` + `ZB: ${this.ZB}, only default values are supported.`);
2689    }
2690    if (this.G < 1) {
2691      info(`Invalid Gamma: ${this.G} for ${this.name}, falling back to default.`);
2692      this.G = 1;
2693    }
2694  }
2695  #toRgb(src, srcOffset, dest, destOffset, scale) {
2696    const A = src[srcOffset] * scale;
2697    const AG = A ** this.G;
2698    const L = this.YW * AG;
2699    const val = Math.max(295.8 * L ** 0.3333333333333333 - 40.8, 0);
2700    dest[destOffset] = val;
2701    dest[destOffset + 1] = val;
2702    dest[destOffset + 2] = val;
2703  }
2704  getRgbItem(src, srcOffset, dest, destOffset) {
2705    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2706  }
2707  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2708    const scale = 1 / ((1 << bits) - 1);
2709    for (let i = 0; i < count; ++i) {
2710      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2711      srcOffset += 1;
2712      destOffset += 3 + alpha01;
2713    }
2714  }
2715  getOutputLength(inputLength, alpha01) {
2716    return inputLength * (3 + alpha01);
2717  }
2718}
2719class CalRGBCS extends ColorSpace {
2720  static #BRADFORD_SCALE_MATRIX = new Float32Array([0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296]);
2721  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]);
2722  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]);
2723  static #FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
2724  static #tempNormalizeMatrix = new Float32Array(3);
2725  static #tempConvertMatrix1 = new Float32Array(3);
2726  static #tempConvertMatrix2 = new Float32Array(3);
2727  static #DECODE_L_CONSTANT = ((8 + 16) / 116) ** 3 / 8.0;
2728  constructor(whitePoint, blackPoint, gamma, matrix) {
2729    super("CalRGB", 3);
2730    if (!whitePoint) {
2731      throw new FormatError("WhitePoint missing - required for color space CalRGB");
2732    }
2733    const [XW, YW, ZW] = this.whitePoint = whitePoint;
2734    const [XB, YB, ZB] = this.blackPoint = blackPoint || new Float32Array(3);
2735    [this.GR, this.GG, this.GB] = gamma || new Float32Array([1, 1, 1]);
2736    [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]);
2737    if (XW < 0 || ZW < 0 || YW !== 1) {
2738      throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);
2739    }
2740    if (XB < 0 || YB < 0 || ZB < 0) {
2741      info(`Invalid BlackPoint for ${this.name} [${XB}, ${YB}, ${ZB}], ` + "falling back to default.");
2742      this.blackPoint = new Float32Array(3);
2743    }
2744    if (this.GR < 0 || this.GG < 0 || this.GB < 0) {
2745      info(`Invalid Gamma [${this.GR}, ${this.GG}, ${this.GB}] for ` + `${this.name}, falling back to default.`);
2746      this.GR = this.GG = this.GB = 1;
2747    }
2748  }
2749  #matrixProduct(a, b, result) {
2750    result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
2751    result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
2752    result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
2753  }
2754  #toFlat(sourceWhitePoint, LMS, result) {
2755    result[0] = LMS[0] * 1 / sourceWhitePoint[0];
2756    result[1] = LMS[1] * 1 / sourceWhitePoint[1];
2757    result[2] = LMS[2] * 1 / sourceWhitePoint[2];
2758  }
2759  #toD65(sourceWhitePoint, LMS, result) {
2760    const D65X = 0.95047;
2761    const D65Y = 1;
2762    const D65Z = 1.08883;
2763    result[0] = LMS[0] * D65X / sourceWhitePoint[0];
2764    result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
2765    result[2] = LMS[2] * D65Z / sourceWhitePoint[2];
2766  }
2767  #sRGBTransferFunction(color) {
2768    if (color <= 0.0031308) {
2769      return this.#adjustToRange(0, 1, 12.92 * color);
2770    }
2771    if (color >= 0.99554525) {
2772      return 1;
2773    }
2774    return this.#adjustToRange(0, 1, (1 + 0.055) * color ** (1 / 2.4) - 0.055);
2775  }
2776  #adjustToRange(min, max, value) {
2777    return Math.max(min, Math.min(max, value));
2778  }
2779  #decodeL(L) {
2780    if (L < 0) {
2781      return -this.#decodeL(-L);
2782    }
2783    if (L > 8.0) {
2784      return ((L + 16) / 116) ** 3;
2785    }
2786    return L * CalRGBCS.#DECODE_L_CONSTANT;
2787  }
2788  #compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
2789    if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {
2790      result[0] = XYZ_Flat[0];
2791      result[1] = XYZ_Flat[1];
2792      result[2] = XYZ_Flat[2];
2793      return;
2794    }
2795    const zeroDecodeL = this.#decodeL(0);
2796    const X_DST = zeroDecodeL;
2797    const X_SRC = this.#decodeL(sourceBlackPoint[0]);
2798    const Y_DST = zeroDecodeL;
2799    const Y_SRC = this.#decodeL(sourceBlackPoint[1]);
2800    const Z_DST = zeroDecodeL;
2801    const Z_SRC = this.#decodeL(sourceBlackPoint[2]);
2802    const X_Scale = (1 - X_DST) / (1 - X_SRC);
2803    const X_Offset = 1 - X_Scale;
2804    const Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
2805    const Y_Offset = 1 - Y_Scale;
2806    const Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
2807    const Z_Offset = 1 - Z_Scale;
2808    result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
2809    result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
2810    result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
2811  }
2812  #normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
2813    if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
2814      result[0] = XYZ_In[0];
2815      result[1] = XYZ_In[1];
2816      result[2] = XYZ_In[2];
2817      return;
2818    }
2819    const LMS = result;
2820    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2821    const LMS_Flat = CalRGBCS.#tempNormalizeMatrix;
2822    this.#toFlat(sourceWhitePoint, LMS, LMS_Flat);
2823    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
2824  }
2825  #normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
2826    const LMS = result;
2827    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
2828    const LMS_D65 = CalRGBCS.#tempNormalizeMatrix;
2829    this.#toD65(sourceWhitePoint, LMS, LMS_D65);
2830    this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
2831  }
2832  #toRgb(src, srcOffset, dest, destOffset, scale) {
2833    const A = this.#adjustToRange(0, 1, src[srcOffset] * scale);
2834    const B = this.#adjustToRange(0, 1, src[srcOffset + 1] * scale);
2835    const C = this.#adjustToRange(0, 1, src[srcOffset + 2] * scale);
2836    const AGR = A === 1 ? 1 : A ** this.GR;
2837    const BGG = B === 1 ? 1 : B ** this.GG;
2838    const CGB = C === 1 ? 1 : C ** this.GB;
2839    const X = this.MXA * AGR + this.MXB * BGG + this.MXC * CGB;
2840    const Y = this.MYA * AGR + this.MYB * BGG + this.MYC * CGB;
2841    const Z = this.MZA * AGR + this.MZB * BGG + this.MZC * CGB;
2842    const XYZ = CalRGBCS.#tempConvertMatrix1;
2843    XYZ[0] = X;
2844    XYZ[1] = Y;
2845    XYZ[2] = Z;
2846    const XYZ_Flat = CalRGBCS.#tempConvertMatrix2;
2847    this.#normalizeWhitePointToFlat(this.whitePoint, XYZ, XYZ_Flat);
2848    const XYZ_Black = CalRGBCS.#tempConvertMatrix1;
2849    this.#compensateBlackPoint(this.blackPoint, XYZ_Flat, XYZ_Black);
2850    const XYZ_D65 = CalRGBCS.#tempConvertMatrix2;
2851    this.#normalizeWhitePointToD65(CalRGBCS.#FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);
2852    const SRGB = CalRGBCS.#tempConvertMatrix1;
2853    this.#matrixProduct(CalRGBCS.#SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
2854    dest[destOffset] = this.#sRGBTransferFunction(SRGB[0]) * 255;
2855    dest[destOffset + 1] = this.#sRGBTransferFunction(SRGB[1]) * 255;
2856    dest[destOffset + 2] = this.#sRGBTransferFunction(SRGB[2]) * 255;
2857  }
2858  getRgbItem(src, srcOffset, dest, destOffset) {
2859    this.#toRgb(src, srcOffset, dest, destOffset, 1);
2860  }
2861  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2862    const scale = 1 / ((1 << bits) - 1);
2863    for (let i = 0; i < count; ++i) {
2864      this.#toRgb(src, srcOffset, dest, destOffset, scale);
2865      srcOffset += 3;
2866      destOffset += 3 + alpha01;
2867    }
2868  }
2869  getOutputLength(inputLength, alpha01) {
2870    return inputLength * (3 + alpha01) / 3 | 0;
2871  }
2872}
2873class LabCS extends ColorSpace {
2874  constructor(whitePoint, blackPoint, range) {
2875    super("Lab", 3);
2876    if (!whitePoint) {
2877      throw new FormatError("WhitePoint missing - required for color space Lab");
2878    }
2879    [this.XW, this.YW, this.ZW] = whitePoint;
2880    [this.amin, this.amax, this.bmin, this.bmax] = range || [-100, 100, -100, 100];
2881    [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
2882    if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
2883      throw new FormatError("Invalid WhitePoint components, no fallback available");
2884    }
2885    if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
2886      info("Invalid BlackPoint, falling back to default");
2887      this.XB = this.YB = this.ZB = 0;
2888    }
2889    if (this.amin > this.amax || this.bmin > this.bmax) {
2890      info("Invalid Range, falling back to defaults");
2891      this.amin = -100;
2892      this.amax = 100;
2893      this.bmin = -100;
2894      this.bmax = 100;
2895    }
2896  }
2897  #fn_g(x) {
2898    return x >= 6 / 29 ? x ** 3 : 108 / 841 * (x - 4 / 29);
2899  }
2900  #decode(value, high1, low2, high2) {
2901    return low2 + value * (high2 - low2) / high1;
2902  }
2903  #toRgb(src, srcOffset, maxVal, dest, destOffset) {
2904    let Ls = src[srcOffset];
2905    let as = src[srcOffset + 1];
2906    let bs = src[srcOffset + 2];
2907    if (maxVal !== false) {
2908      Ls = this.#decode(Ls, maxVal, 0, 100);
2909      as = this.#decode(as, maxVal, this.amin, this.amax);
2910      bs = this.#decode(bs, maxVal, this.bmin, this.bmax);
2911    }
2912    if (as > this.amax) {
2913      as = this.amax;
2914    } else if (as < this.amin) {
2915      as = this.amin;
2916    }
2917    if (bs > this.bmax) {
2918      bs = this.bmax;
2919    } else if (bs < this.bmin) {
2920      bs = this.bmin;
2921    }
2922    const M = (Ls + 16) / 116;
2923    const L = M + as / 500;
2924    const N = M - bs / 200;
2925    const X = this.XW * this.#fn_g(L);
2926    const Y = this.YW * this.#fn_g(M);
2927    const Z = this.ZW * this.#fn_g(N);
2928    let r, g, b;
2929    if (this.ZW < 1) {
2930      r = X * 3.1339 + Y * -1.617 + Z * -0.4906;
2931      g = X * -0.9785 + Y * 1.916 + Z * 0.0333;
2932      b = X * 0.072 + Y * -0.229 + Z * 1.4057;
2933    } else {
2934      r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
2935      g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
2936      b = X * 0.0557 + Y * -0.204 + Z * 1.057;
2937    }
2938    dest[destOffset] = Math.sqrt(r) * 255;
2939    dest[destOffset + 1] = Math.sqrt(g) * 255;
2940    dest[destOffset + 2] = Math.sqrt(b) * 255;
2941  }
2942  getRgbItem(src, srcOffset, dest, destOffset) {
2943    this.#toRgb(src, srcOffset, false, dest, destOffset);
2944  }
2945  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
2946    const maxVal = (1 << bits) - 1;
2947    for (let i = 0; i < count; i++) {
2948      this.#toRgb(src, srcOffset, maxVal, dest, destOffset);
2949      srcOffset += 3;
2950      destOffset += 3 + alpha01;
2951    }
2952  }
2953  getOutputLength(inputLength, alpha01) {
2954    return inputLength * (3 + alpha01) / 3 | 0;
2955  }
2956  isDefaultDecode(decodeMap, bpc) {
2957    return true;
2958  }
2959  get usesZeroToOneRange() {
2960    return shadow(this, "usesZeroToOneRange", false);
2961  }
2962}
2963
2964;// ./src/core/binary_cmap.js
2965
2966function hexToInt(a, size) {
2967  let n = 0;
2968  for (let i = 0; i <= size; i++) {
2969    n = n << 8 | a[i];
2970  }
2971  return n >>> 0;
2972}
2973function hexToStr(a, size) {
2974  if (size === 1) {
2975    return String.fromCharCode(a[0], a[1]);
2976  }
2977  if (size === 3) {
2978    return String.fromCharCode(a[0], a[1], a[2], a[3]);
2979  }
2980  return String.fromCharCode(...a.subarray(0, size + 1));
2981}
2982function addHex(a, b, size) {
2983  let c = 0;
2984  for (let i = size; i >= 0; i--) {
2985    c += a[i] + b[i];
2986    a[i] = c & 255;
2987    c >>= 8;
2988  }
2989}
2990function incHex(a, size) {
2991  let c = 1;
2992  for (let i = size; i >= 0 && c > 0; i--) {
2993    c += a[i];
2994    a[i] = c & 255;
2995    c >>= 8;
2996  }
2997}
2998const MAX_NUM_SIZE = 16;
2999const MAX_ENCODED_NUM_SIZE = 19;
3000class BinaryCMapStream {
3001  constructor(data) {
3002    this.buffer = data;
3003    this.pos = 0;
3004    this.end = data.length;
3005    this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE);
3006  }
3007  readByte() {
3008    if (this.pos >= this.end) {
3009      return -1;
3010    }
3011    return this.buffer[this.pos++];
3012  }
3013  readNumber() {
3014    let n = 0;
3015    let last;
3016    do {
3017      const b = this.readByte();
3018      if (b < 0) {
3019        throw new FormatError("unexpected EOF in bcmap");
3020      }
3021      last = !(b & 0x80);
3022      n = n << 7 | b & 0x7f;
3023    } while (!last);
3024    return n;
3025  }
3026  readSigned() {
3027    const n = this.readNumber();
3028    return n & 1 ? ~(n >>> 1) : n >>> 1;
3029  }
3030  readHex(num, size) {
3031    num.set(this.buffer.subarray(this.pos, this.pos + size + 1));
3032    this.pos += size + 1;
3033  }
3034  readHexNumber(num, size) {
3035    let last;
3036    const stack = this.tmpBuf;
3037    let sp = 0;
3038    do {
3039      const b = this.readByte();
3040      if (b < 0) {
3041        throw new FormatError("unexpected EOF in bcmap");
3042      }
3043      last = !(b & 0x80);
3044      stack[sp++] = b & 0x7f;
3045    } while (!last);
3046    let i = size,
3047      buffer = 0,
3048      bufferSize = 0;
3049    while (i >= 0) {
3050      while (bufferSize < 8 && stack.length > 0) {
3051        buffer |= stack[--sp] << bufferSize;
3052        bufferSize += 7;
3053      }
3054      num[i] = buffer & 255;
3055      i--;
3056      buffer >>= 8;
3057      bufferSize -= 8;
3058    }
3059  }
3060  readHexSigned(num, size) {
3061    this.readHexNumber(num, size);
3062    const sign = num[size] & 1 ? 255 : 0;
3063    let c = 0;
3064    for (let i = 0; i <= size; i++) {
3065      c = (c & 1) << 8 | num[i];
3066      num[i] = c >> 1 ^ sign;
3067    }
3068  }
3069  readString() {
3070    const len = this.readNumber(),
3071      buf = new Array(len);
3072    for (let i = 0; i < len; i++) {
3073      buf[i] = this.readNumber();
3074    }
3075    return String.fromCharCode(...buf);
3076  }
3077}
3078class BinaryCMapReader {
3079  async process(data, cMap, extend) {
3080    const stream = new BinaryCMapStream(data);
3081    const header = stream.readByte();
3082    cMap.vertical = !!(header & 1);
3083    let useCMap = null;
3084    const start = new Uint8Array(MAX_NUM_SIZE);
3085    const end = new Uint8Array(MAX_NUM_SIZE);
3086    const char = new Uint8Array(MAX_NUM_SIZE);
3087    const charCode = new Uint8Array(MAX_NUM_SIZE);
3088    const tmp = new Uint8Array(MAX_NUM_SIZE);
3089    let code;
3090    let b;
3091    while ((b = stream.readByte()) >= 0) {
3092      const type = b >> 5;
3093      if (type === 7) {
3094        switch (b & 0x1f) {
3095          case 0:
3096            stream.readString();
3097            break;
3098          case 1:
3099            useCMap = stream.readString();
3100            break;
3101        }
3102        continue;
3103      }
3104      const sequence = !!(b & 0x10);
3105      const dataSize = b & 15;
3106      if (dataSize + 1 > MAX_NUM_SIZE) {
3107        throw new Error("BinaryCMapReader.process: Invalid dataSize.");
3108      }
3109      const ucs2DataSize = 1;
3110      const subitemsCount = stream.readNumber();
3111      switch (type) {
3112        case 0:
3113          stream.readHex(start, dataSize);
3114          stream.readHexNumber(end, dataSize);
3115          addHex(end, start, dataSize);
3116          cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
3117          for (let i = 1; i < subitemsCount; i++) {
3118            incHex(end, dataSize);
3119            stream.readHexNumber(start, dataSize);
3120            addHex(start, end, dataSize);
3121            stream.readHexNumber(end, dataSize);
3122            addHex(end, start, dataSize);
3123            cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
3124          }
3125          break;
3126        case 1:
3127          stream.readHex(start, dataSize);
3128          stream.readHexNumber(end, dataSize);
3129          addHex(end, start, dataSize);
3130          stream.readNumber();
3131          for (let i = 1; i < subitemsCount; i++) {
3132            incHex(end, dataSize);
3133            stream.readHexNumber(start, dataSize);
3134            addHex(start, end, dataSize);
3135            stream.readHexNumber(end, dataSize);
3136            addHex(end, start, dataSize);
3137            stream.readNumber();
3138          }
3139          break;
3140        case 2:
3141          stream.readHex(char, dataSize);
3142          code = stream.readNumber();
3143          cMap.mapOne(hexToInt(char, dataSize), code);
3144          for (let i = 1; i < subitemsCount; i++) {
3145            incHex(char, dataSize);
3146            if (!sequence) {
3147              stream.readHexNumber(tmp, dataSize);
3148              addHex(char, tmp, dataSize);
3149            }
3150            code = stream.readSigned() + (code + 1);
3151            cMap.mapOne(hexToInt(char, dataSize), code);
3152          }
3153          break;
3154        case 3:
3155          stream.readHex(start, dataSize);
3156          stream.readHexNumber(end, dataSize);
3157          addHex(end, start, dataSize);
3158          code = stream.readNumber();
3159          cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
3160          for (let i = 1; i < subitemsCount; i++) {
3161            incHex(end, dataSize);
3162            if (!sequence) {
3163              stream.readHexNumber(start, dataSize);
3164              addHex(start, end, dataSize);
3165            } else {
3166              start.set(end);
3167            }
3168            stream.readHexNumber(end, dataSize);
3169            addHex(end, start, dataSize);
3170            code = stream.readNumber();
3171            cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
3172          }
3173          break;
3174        case 4:
3175          stream.readHex(char, ucs2DataSize);
3176          stream.readHex(charCode, dataSize);
3177          cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
3178          for (let i = 1; i < subitemsCount; i++) {
3179            incHex(char, ucs2DataSize);
3180            if (!sequence) {
3181              stream.readHexNumber(tmp, ucs2DataSize);
3182              addHex(char, tmp, ucs2DataSize);
3183            }
3184            incHex(charCode, dataSize);
3185            stream.readHexSigned(tmp, dataSize);
3186            addHex(charCode, tmp, dataSize);
3187            cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
3188          }
3189          break;
3190        case 5:
3191          stream.readHex(start, ucs2DataSize);
3192          stream.readHexNumber(end, ucs2DataSize);
3193          addHex(end, start, ucs2DataSize);
3194          stream.readHex(charCode, dataSize);
3195          cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
3196          for (let i = 1; i < subitemsCount; i++) {
3197            incHex(end, ucs2DataSize);
3198            if (!sequence) {
3199              stream.readHexNumber(start, ucs2DataSize);
3200              addHex(start, end, ucs2DataSize);
3201            } else {
3202              start.set(end);
3203            }
3204            stream.readHexNumber(end, ucs2DataSize);
3205            addHex(end, start, ucs2DataSize);
3206            stream.readHex(charCode, dataSize);
3207            cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
3208          }
3209          break;
3210        default:
3211          throw new Error(`BinaryCMapReader.process - unknown type: ${type}`);
3212      }
3213    }
3214    if (useCMap) {
3215      return extend(useCMap);
3216    }
3217    return cMap;
3218  }
3219}
3220
3221;// ./src/core/decode_stream.js
3222
3223
3224const emptyBuffer = new Uint8Array(0);
3225class DecodeStream extends BaseStream {
3226  constructor(maybeMinBufferLength) {
3227    super();
3228    this._rawMinBufferLength = maybeMinBufferLength || 0;
3229    this.pos = 0;
3230    this.bufferLength = 0;
3231    this.eof = false;
3232    this.buffer = emptyBuffer;
3233    this.minBufferLength = 512;
3234    if (maybeMinBufferLength) {
3235      while (this.minBufferLength < maybeMinBufferLength) {
3236        this.minBufferLength *= 2;
3237      }
3238    }
3239  }
3240  get isEmpty() {
3241    while (!this.eof && this.bufferLength === 0) {
3242      this.readBlock();
3243    }
3244    return this.bufferLength === 0;
3245  }
3246  ensureBuffer(requested) {
3247    const buffer = this.buffer;
3248    if (requested <= buffer.byteLength) {
3249      return buffer;
3250    }
3251    let size = this.minBufferLength;
3252    while (size < requested) {
3253      size *= 2;
3254    }
3255    const buffer2 = new Uint8Array(size);
3256    buffer2.set(buffer);
3257    return this.buffer = buffer2;
3258  }
3259  getByte() {
3260    const pos = this.pos;
3261    while (this.bufferLength <= pos) {
3262      if (this.eof) {
3263        return -1;
3264      }
3265      this.readBlock();
3266    }
3267    return this.buffer[this.pos++];
3268  }
3269  getBytes(length, decoderOptions = null) {
3270    const pos = this.pos;
3271    let end;
3272    if (length) {
3273      this.ensureBuffer(pos + length);
3274      end = pos + length;
3275      while (!this.eof && this.bufferLength < end) {
3276        this.readBlock(decoderOptions);
3277      }
3278      const bufEnd = this.bufferLength;
3279      if (end > bufEnd) {
3280        end = bufEnd;
3281      }
3282    } else {
3283      while (!this.eof) {
3284        this.readBlock(decoderOptions);
3285      }
3286      end = this.bufferLength;
3287    }
3288    this.pos = end;
3289    return this.buffer.subarray(pos, end);
3290  }
3291  async getImageData(length, decoderOptions = null) {
3292    if (!this.canAsyncDecodeImageFromBuffer) {
3293      return this.getBytes(length, decoderOptions);
3294    }
3295    const data = await this.stream.asyncGetBytes();
3296    return this.decodeImage(data, decoderOptions);
3297  }
3298  reset() {
3299    this.pos = 0;
3300  }
3301  makeSubStream(start, length, dict = null) {
3302    if (length === undefined) {
3303      while (!this.eof) {
3304        this.readBlock();
3305      }
3306    } else {
3307      const end = start + length;
3308      while (this.bufferLength <= end && !this.eof) {
3309        this.readBlock();
3310      }
3311    }
3312    return new Stream(this.buffer, start, length, dict);
3313  }
3314  getBaseStreams() {
3315    return this.str ? this.str.getBaseStreams() : null;
3316  }
3317}
3318class StreamsSequenceStream extends DecodeStream {
3319  constructor(streams, onError = null) {
3320    streams = streams.filter(s => s instanceof BaseStream);
3321    let maybeLength = 0;
3322    for (const stream of streams) {
3323      maybeLength += stream instanceof DecodeStream ? stream._rawMinBufferLength : stream.length;
3324    }
3325    super(maybeLength);
3326    this.streams = streams;
3327    this._onError = onError;
3328  }
3329  readBlock() {
3330    const streams = this.streams;
3331    if (streams.length === 0) {
3332      this.eof = true;
3333      return;
3334    }
3335    const stream = streams.shift();
3336    let chunk;
3337    try {
3338      chunk = stream.getBytes();
3339    } catch (reason) {
3340      if (this._onError) {
3341        this._onError(reason, stream.dict?.objId);
3342        return;
3343      }
3344      throw reason;
3345    }
3346    const bufferLength = this.bufferLength;
3347    const newLength = bufferLength + chunk.length;
3348    const buffer = this.ensureBuffer(newLength);
3349    buffer.set(chunk, bufferLength);
3350    this.bufferLength = newLength;
3351  }
3352  getBaseStreams() {
3353    const baseStreamsBuf = [];
3354    for (const stream of this.streams) {
3355      const baseStreams = stream.getBaseStreams();
3356      if (baseStreams) {
3357        baseStreamsBuf.push(...baseStreams);
3358      }
3359    }
3360    return baseStreamsBuf.length > 0 ? baseStreamsBuf : null;
3361  }
3362}
3363
3364;// ./src/core/ascii_85_stream.js
3365
3366
3367class Ascii85Stream extends DecodeStream {
3368  constructor(str, maybeLength) {
3369    if (maybeLength) {
3370      maybeLength *= 0.8;
3371    }
3372    super(maybeLength);
3373    this.str = str;
3374    this.dict = str.dict;
3375    this.input = new Uint8Array(5);
3376  }
3377  readBlock() {
3378    const TILDA_CHAR = 0x7e;
3379    const Z_LOWER_CHAR = 0x7a;
3380    const EOF = -1;
3381    const str = this.str;
3382    let c = str.getByte();
3383    while (isWhiteSpace(c)) {
3384      c = str.getByte();
3385    }
3386    if (c === EOF || c === TILDA_CHAR) {
3387      this.eof = true;
3388      return;
3389    }
3390    const bufferLength = this.bufferLength;
3391    let buffer, i;
3392    if (c === Z_LOWER_CHAR) {
3393      buffer = this.ensureBuffer(bufferLength + 4);
3394      for (i = 0; i < 4; ++i) {
3395        buffer[bufferLength + i] = 0;
3396      }
3397      this.bufferLength += 4;
3398    } else {
3399      const input = this.input;
3400      input[0] = c;
3401      for (i = 1; i < 5; ++i) {
3402        c = str.getByte();
3403        while (isWhiteSpace(c)) {
3404          c = str.getByte();
3405        }
3406        input[i] = c;
3407        if (c === EOF || c === TILDA_CHAR) {
3408          break;
3409        }
3410      }
3411      buffer = this.ensureBuffer(bufferLength + i - 1);
3412      this.bufferLength += i - 1;
3413      if (i < 5) {
3414        for (; i < 5; ++i) {
3415          input[i] = 0x21 + 84;
3416        }
3417        this.eof = true;
3418      }
3419      let t = 0;
3420      for (i = 0; i < 5; ++i) {
3421        t = t * 85 + (input[i] - 0x21);
3422      }
3423      for (i = 3; i >= 0; --i) {
3424        buffer[bufferLength + i] = t & 0xff;
3425        t >>= 8;
3426      }
3427    }
3428  }
3429}
3430
3431;// ./src/core/ascii_hex_stream.js
3432
3433class AsciiHexStream extends DecodeStream {
3434  constructor(str, maybeLength) {
3435    if (maybeLength) {
3436      maybeLength *= 0.5;
3437    }
3438    super(maybeLength);
3439    this.str = str;
3440    this.dict = str.dict;
3441    this.firstDigit = -1;
3442  }
3443  readBlock() {
3444    const UPSTREAM_BLOCK_SIZE = 8000;
3445    const bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);
3446    if (!bytes.length) {
3447      this.eof = true;
3448      return;
3449    }
3450    const maxDecodeLength = bytes.length + 1 >> 1;
3451    const buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
3452    let bufferLength = this.bufferLength;
3453    let firstDigit = this.firstDigit;
3454    for (const ch of bytes) {
3455      let digit;
3456      if (ch >= 0x30 && ch <= 0x39) {
3457        digit = ch & 0x0f;
3458      } else if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
3459        digit = (ch & 0x0f) + 9;
3460      } else if (ch === 0x3e) {
3461        this.eof = true;
3462        break;
3463      } else {
3464        continue;
3465      }
3466      if (firstDigit < 0) {
3467        firstDigit = digit;
3468      } else {
3469        buffer[bufferLength++] = firstDigit << 4 | digit;
3470        firstDigit = -1;
3471      }
3472    }
3473    if (firstDigit >= 0 && this.eof) {
3474      buffer[bufferLength++] = firstDigit << 4;
3475      firstDigit = -1;
3476    }
3477    this.firstDigit = firstDigit;
3478    this.bufferLength = bufferLength;
3479  }
3480}
3481
3482;// ./src/core/ccitt.js