https://conversiontab.com/build/assets/pdf.worker-BgryrOlp.mjs

1/**
2 * @licstart The following is the entire license notice for the
3 * JavaScript code in this page
4 *
5 * Copyright 2024 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * JavaScript code in this page
21 */
22
23/******/ // 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  DRAW_STEP: 41
101};
102const PermissionFlag = {
103  PRINT: 0x04,
104  MODIFY_CONTENTS: 0x08,
105  COPY: 0x10,
106  MODIFY_ANNOTATIONS: 0x20,
107  FILL_INTERACTIVE_FORMS: 0x100,
108  COPY_FOR_ACCESSIBILITY: 0x200,
109  ASSEMBLE: 0x400,
110  PRINT_HIGH_QUALITY: 0x800
111};
112const TextRenderingMode = {
113  FILL: 0,
114  STROKE: 1,
115  FILL_STROKE: 2,
116  INVISIBLE: 3,
117  FILL_ADD_TO_PATH: 4,
118  STROKE_ADD_TO_PATH: 5,
119  FILL_STROKE_ADD_TO_PATH: 6,
120  ADD_TO_PATH: 7,
121  FILL_STROKE_MASK: 3,
122  ADD_TO_PATH_FLAG: 4
123};
124const ImageKind = {
125  GRAYSCALE_1BPP: 1,
126  RGB_24BPP: 2,
127  RGBA_32BPP: 3
128};
129const AnnotationType = {
130  TEXT: 1,
131  LINK: 2,
132  FREETEXT: 3,
133  LINE: 4,
134  SQUARE: 5,
135  CIRCLE: 6,
136  POLYGON: 7,
137  POLYLINE: 8,
138  HIGHLIGHT: 9,
139  UNDERLINE: 10,
140  SQUIGGLY: 11,
141  STRIKEOUT: 12,
142  STAMP: 13,
143  CARET: 14,
144  INK: 15,
145  POPUP: 16,
146  FILEATTACHMENT: 17,
147  SOUND: 18,
148  MOVIE: 19,
149  WIDGET: 20,
150  SCREEN: 21,
151  PRINTERMARK: 22,
152  TRAPNET: 23,
153  WATERMARK: 24,
154  THREED: 25,
155  REDACT: 26
156};
157const AnnotationReplyType = {
158  GROUP: "Group",
159  REPLY: "R"
160};
161const AnnotationFlag = {
162  INVISIBLE: 0x01,
163  HIDDEN: 0x02,
164  PRINT: 0x04,
165  NOZOOM: 0x08,

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

708      try {
709        const decoder = new TextDecoder(encoding, {
710          fatal: true
711        });
712        const buffer = stringToBytes(str);
713        const decoded = decoder.decode(buffer);
714        if (!decoded.includes("\x1b")) {
715          return decoded;
716        }
717        return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
718      } catch (ex) {
719        warn(`stringToPDFString: "${ex}".`);
720      }
721    }
722  }
723  const strBuf = [];
724  for (let i = 0, ii = str.length; i < ii; i++) {
725    const charCode = str.charCodeAt(i);
726    if (charCode === 0x1b) {
727      while (++i < ii && str.charCodeAt(i) !== 0x1b) {}
728      continue;
729    }
730    const code = PDFStringTranslateTable[charCode];
731    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
732  }
733  return strBuf.join("");
734}
735function stringToUTF8String(str) {
736  return decodeURIComponent(escape(str));
737}
738function utf8StringToString(str) {
739  return unescape(encodeURIComponent(str));
740}
741function isArrayEqual(arr1, arr2) {
742  if (arr1.length !== arr2.length) {
743    return false;
744  }
745  for (let i = 0, ii = arr1.length; i < ii; i++) {
746    if (arr1[i] !== arr2[i]) {
747      return false;
748    }
749  }
750  return true;
751}
752function getModificationDate(date = new Date()) {
753  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")];
754  return buffer.join("");
755}
756let NormalizeRegex = null;
757let NormalizationMap = null;
758function normalizeUnicode(str) {
759  if (!NormalizeRegex) {
760    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;
761    NormalizationMap = new Map([["ſt", "ſt"]]);
762  }
763  return str.replaceAll(NormalizeRegex, (_, p1, p2) => p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2));
764}
765function getUuid() {
766  if (typeof crypto.randomUUID === "function") {
767    return crypto.randomUUID();
768  }
769  const buf = new Uint8Array(32);
770  crypto.getRandomValues(buf);
771  return bytesToString(buf);
772}
773const AnnotationPrefix = "pdfjs_internal_id_";
774function toHexUtil(arr) {
775  if (Uint8Array.prototype.toHex) {
776    return arr.toHex();
777  }
778  return Array.from(arr, num => hexNumbers[num]).join("");
779}
780function toBase64Util(arr) {
781  if (Uint8Array.prototype.toBase64) {
782    return arr.toBase64();
783  }
784  return btoa(bytesToString(arr));
785}
786function fromBase64Util(str) {
787  if (Uint8Array.fromBase64) {
788    return Uint8Array.fromBase64(str);
789  }
790  return stringToBytes(atob(str));
791}
792if (typeof Promise.try !== "function") {
793  Promise.try = function (fn, ...args) {
794    return new Promise(resolve => {
795      resolve(fn(...args));
796    });
797  };
798}
799
800;// ./src/core/primitives.js
801
802const CIRCULAR_REF = Symbol("CIRCULAR_REF");
803const EOF = Symbol("EOF");
804let CmdCache = Object.create(null);
805let NameCache = Object.create(null);
806let RefCache = Object.create(null);
807function clearPrimitiveCaches() {
808  CmdCache = Object.create(null);
809  NameCache = Object.create(null);
810  RefCache = Object.create(null);
811}
812class Name {
813  constructor(name) {
814    this.name = name;
815  }
816  static get(name) {
817    return NameCache[name] ||= new Name(name);
818  }
819}
820class Cmd {
821  constructor(cmd) {
822    this.cmd = cmd;
823  }
824  static get(cmd) {
825    return CmdCache[cmd] ||= new Cmd(cmd);
826  }
827}
828const nonSerializable = function nonSerializableClosure() {
829  return nonSerializable;
830};
831class Dict {
832  constructor(xref = null) {
833    this._map = new Map();
834    this.xref = xref;
835    this.objId = null;
836    this.suppressEncryption = false;
837    this.__nonSerializable__ = nonSerializable;
838  }
839  assignXref(newXref) {
840    this.xref = newXref;
841  }
842  get size() {
843    return this._map.size;
844  }
845  get(key1, key2, key3) {
846    let value = this._map.get(key1);
847    if (value === undefined && key2 !== undefined) {
848      value = this._map.get(key2);
849      if (value === undefined && key3 !== undefined) {
850        value = this._map.get(key3);
851      }
852    }
853    if (value instanceof Ref && this.xref) {
854      return this.xref.fetch(value, this.suppressEncryption);
855    }
856    return value;
857  }
858  async getAsync(key1, key2, key3) {
859    let value = this._map.get(key1);
860    if (value === undefined && key2 !== undefined) {
861      value = this._map.get(key2);
862      if (value === undefined && key3 !== undefined) {
863        value = this._map.get(key3);
864      }
865    }
866    if (value instanceof Ref && this.xref) {
867      return this.xref.fetchAsync(value, this.suppressEncryption);
868    }
869    return value;
870  }
871  getArray(key1, key2, key3) {
872    let value = this._map.get(key1);
873    if (value === undefined && key2 !== undefined) {
874      value = this._map.get(key2);
875      if (value === undefined && key3 !== undefined) {
876        value = this._map.get(key3);
877      }
878    }
879    if (value instanceof Ref && this.xref) {
880      value = this.xref.fetch(value, this.suppressEncryption);
881    }
882    if (Array.isArray(value)) {
883      value = value.slice();
884      for (let i = 0, ii = value.length; i < ii; i++) {
885        if (value[i] instanceof Ref && this.xref) {
886          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
887        }
888      }
889    }
890    return value;
891  }
892  getRaw(key) {
893    return this._map.get(key);
894  }
895  getKeys() {
896    return [...this._map.keys()];
897  }
898  getRawValues() {
899    return [...this._map.values()];
900  }
901  set(key, value) {
902    this._map.set(key, value);
903  }
904  has(key) {
905    return this._map.has(key);
906  }
907  *[Symbol.iterator]() {
908    for (const [key, value] of this._map) {
909      yield [key, value instanceof Ref && this.xref ? this.xref.fetch(value, this.suppressEncryption) : value];
910    }
911  }
912  static get empty() {
913    const emptyDict = new Dict(null);
914    emptyDict.set = (key, value) => {
915      unreachable("Should not call `set` on the empty dictionary.");
916    };
917    return shadow(this, "empty", emptyDict);
918  }
919  static merge({
920    xref,
921    dictArray,
922    mergeSubDicts = false
923  }) {
924    const mergedDict = new Dict(xref),
925      properties = new Map();
926    for (const dict of dictArray) {
927      if (!(dict instanceof Dict)) {
928        continue;
929      }
930      for (const [key, value] of dict._map) {
931        let property = properties.get(key);
932        if (property === undefined) {
933          property = [];
934          properties.set(key, property);
935        } else if (!mergeSubDicts || !(value instanceof Dict)) {
936          continue;
937        }
938        property.push(value);
939      }
940    }
941    for (const [name, values] of properties) {
942      if (values.length === 1 || !(values[0] instanceof Dict)) {
943        mergedDict._map.set(name, values[0]);
944        continue;
945      }
946      const subDict = new Dict(xref);
947      for (const dict of values) {
948        for (const [key, value] of dict._map) {
949          if (!subDict._map.has(key)) {
950            subDict._map.set(key, value);
951          }
952        }
953      }
954      if (subDict.size > 0) {
955        mergedDict._map.set(name, subDict);
956      }
957    }
958    properties.clear();
959    return mergedDict.size > 0 ? mergedDict : Dict.empty;
960  }
961  clone() {
962    const dict = new Dict(this.xref);
963    for (const key of this.getKeys()) {
964      dict.set(key, this.getRaw(key));
965    }
966    return dict;
967  }
968  delete(key) {
969    delete this._map[key];
970  }
971}
972class Ref {
973  constructor(num, gen) {
974    this.num = num;
975    this.gen = gen;
976  }
977  toString() {
978    if (this.gen === 0) {
979      return `${this.num}R`;
980    }
981    return `${this.num}R${this.gen}`;
982  }
983  static fromString(str) {
984    const ref = RefCache[str];
985    if (ref) {
986      return ref;
987    }
988    const m = /^(\d+)R(\d*)$/.exec(str);
989    if (!m || m[1] === "0") {
990      return null;
991    }
992    return RefCache[str] = new Ref(parseInt(m[1]), !m[2] ? 0 : parseInt(m[2]));
993  }
994  static get(num, gen) {
995    const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
996    return RefCache[key] ||= new Ref(num, gen);
997  }
998}
999class RefSet {
1000  constructor(parent = null) {
1001    this._set = new Set(parent?._set);
1002  }
1003  has(ref) {
1004    return this._set.has(ref.toString());
1005  }
1006  put(ref) {
1007    this._set.add(ref.toString());
1008  }
1009  remove(ref) {
1010    this._set.delete(ref.toString());
1011  }
1012  [Symbol.iterator]() {
1013    return this._set.values();
1014  }
1015  clear() {
1016    this._set.clear();
1017  }
1018}
1019class RefSetCache {
1020  constructor() {
1021    this._map = new Map();
1022  }
1023  get size() {
1024    return this._map.size;
1025  }
1026  get(ref) {
1027    return this._map.get(ref.toString());
1028  }
1029  has(ref) {
1030    return this._map.has(ref.toString());
1031  }
1032  put(ref, obj) {
1033    this._map.set(ref.toString(), obj);
1034  }
1035  putAlias(ref, aliasRef) {
1036    this._map.set(ref.toString(), this.get(aliasRef));
1037  }
1038  [Symbol.iterator]() {
1039    return this._map.values();
1040  }
1041  clear() {
1042    this._map.clear();
1043  }
1044  *values() {
1045    yield* this._map.values();
1046  }
1047  *items() {
1048    for (const [ref, value] of this._map) {
1049      yield [Ref.fromString(ref), value];
1050    }
1051  }
1052}
1053function isName(v, name) {
1054  return v instanceof Name && (name === undefined || v.name === name);
1055}
1056function isCmd(v, cmd) {
1057  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
1058}
1059function isDict(v, type) {
1060  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
1061}
1062function isRefsEqual(v1, v2) {
1063  return v1.num === v2.num && v1.gen === v2.gen;
1064}
1065
1066;// ./src/core/base_stream.js
1067
1068class BaseStream {
1069  get length() {
1070    unreachable("Abstract getter `length` accessed");
1071  }
1072  get isEmpty() {
1073    unreachable("Abstract getter `isEmpty` accessed");
1074  }
1075  get isDataLoaded() {
1076    return shadow(this, "isDataLoaded", true);
1077  }
1078  getByte() {
1079    unreachable("Abstract method `getByte` called");
1080  }
1081  getBytes(length) {
1082    unreachable("Abstract method `getBytes` called");
1083  }
1084  async getImageData(length, decoderOptions) {
1085    return this.getBytes(length, decoderOptions);
1086  }
1087  async asyncGetBytes() {
1088    unreachable("Abstract method `asyncGetBytes` called");
1089  }
1090  get isAsync() {
1091    return false;
1092  }
1093  get canAsyncDecodeImageFromBuffer() {
1094    return false;
1095  }
1096  async getTransferableImage() {
1097    return null;
1098  }
1099  peekByte() {
1100    const peekedByte = this.getByte();
1101    if (peekedByte !== -1) {
1102      this.pos--;
1103    }
1104    return peekedByte;
1105  }
1106  peekBytes(length) {
1107    const bytes = this.getBytes(length);
1108    this.pos -= bytes.length;
1109    return bytes;
1110  }
1111  getUint16() {
1112    const b0 = this.getByte();
1113    const b1 = this.getByte();
1114    if (b0 === -1 || b1 === -1) {
1115      return -1;
1116    }
1117    return (b0 << 8) + b1;
1118  }
1119  getInt32() {
1120    const b0 = this.getByte();
1121    const b1 = this.getByte();
1122    const b2 = this.getByte();
1123    const b3 = this.getByte();
1124    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1125  }
1126  getByteRange(begin, end) {
1127    unreachable("Abstract method `getByteRange` called");
1128  }
1129  getString(length) {
1130    return bytesToString(this.getBytes(length));
1131  }
1132  skip(n) {
1133    this.pos += n || 1;
1134  }
1135  reset() {
1136    unreachable("Abstract method `reset` called");
1137  }
1138  moveStart() {
1139    unreachable("Abstract method `moveStart` called");
1140  }
1141  makeSubStream(start, length, dict = null) {
1142    unreachable("Abstract method `makeSubStream` called");
1143  }
1144  getBaseStreams() {
1145    return null;
1146  }
1147}
1148
1149;// ./src/core/core_utils.js
1150
1151
1152
1153const PDF_VERSION_REGEXP = /^[1-9]\.\d$/;
1154const MAX_INT_32 = 2 ** 31 - 1;
1155const MIN_INT_32 = -(2 ** 31);
1156function getLookupTableFactory(initializer) {
1157  let lookup;
1158  return function () {
1159    if (initializer) {
1160      lookup = Object.create(null);
1161      initializer(lookup);
1162      initializer = null;
1163    }
1164    return lookup;
1165  };
1166}
1167class MissingDataException extends BaseException {
1168  constructor(begin, end) {
1169    super(`Missing data [${begin}, ${end})`, "MissingDataException");
1170    this.begin = begin;
1171    this.end = end;
1172  }
1173}
1174class ParserEOFException extends BaseException {
1175  constructor(msg) {
1176    super(msg, "ParserEOFException");
1177  }
1178}
1179class XRefEntryException extends BaseException {
1180  constructor(msg) {
1181    super(msg, "XRefEntryException");
1182  }
1183}
1184class XRefParseException extends BaseException {
1185  constructor(msg) {
1186    super(msg, "XRefParseException");
1187  }
1188}
1189function arrayBuffersToBytes(arr) {
1190  const length = arr.length;
1191  if (length === 0) {
1192    return new Uint8Array(0);
1193  }
1194  if (length === 1) {
1195    return new Uint8Array(arr[0]);
1196  }
1197  let dataLength = 0;
1198  for (let i = 0; i < length; i++) {
1199    dataLength += arr[i].byteLength;
1200  }
1201  const data = new Uint8Array(dataLength);
1202  let pos = 0;
1203  for (let i = 0; i < length; i++) {
1204    const item = new Uint8Array(arr[i]);
1205    data.set(item, pos);
1206    pos += item.byteLength;
1207  }
1208  return data;
1209}
1210function getInheritableProperty({
1211  dict,
1212  key,
1213  getArray = false,
1214  stopWhenFound = true
1215}) {
1216  let values;
1217  const visited = new RefSet();
1218  while (dict instanceof Dict && !(dict.objId && visited.has(dict.objId))) {
1219    if (dict.objId) {
1220      visited.put(dict.objId);
1221    }
1222    const value = getArray ? dict.getArray(key) : dict.get(key);
1223    if (value !== undefined) {
1224      if (stopWhenFound) {
1225        return value;
1226      }
1227      (values ||= []).push(value);
1228    }
1229    dict = dict.get("Parent");
1230  }
1231  return values;
1232}
1233function getParentToUpdate(dict, ref, xref) {
1234  const visited = new RefSet();
1235  const firstDict = dict;
1236  const result = {
1237    dict: null,
1238    ref: null
1239  };
1240  while (dict instanceof Dict && !visited.has(ref)) {
1241    visited.put(ref);
1242    if (dict.has("T")) {
1243      break;
1244    }
1245    ref = dict.getRaw("Parent");
1246    if (!(ref instanceof Ref)) {
1247      return result;
1248    }
1249    dict = xref.fetch(ref);
1250  }
1251  if (dict instanceof Dict && dict !== firstDict) {
1252    result.dict = dict;
1253    result.ref = ref;
1254  }
1255  return result;
1256}
1257const 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"];
1258function toRomanNumerals(number, lowerCase = false) {
1259  assert(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
1260  const roman = "M".repeat(number / 1000 | 0) + ROMAN_NUMBER_MAP[number % 1000 / 100 | 0] + ROMAN_NUMBER_MAP[10 + (number % 100 / 10 | 0)] + ROMAN_NUMBER_MAP[20 + number % 10];
1261  return lowerCase ? roman.toLowerCase() : roman;
1262}
1263function log2(x) {
1264  return x > 0 ? Math.ceil(Math.log2(x)) : 0;
1265}
1266function readInt8(data, offset) {
1267  return data[offset] << 24 >> 24;
1268}
1269function readUint16(data, offset) {
1270  return data[offset] << 8 | data[offset + 1];
1271}
1272function readUint32(data, offset) {
1273  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
1274}
1275function isWhiteSpace(ch) {
1276  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
1277}
1278function isBooleanArray(arr, len) {
1279  return Array.isArray(arr) && (len === null || arr.length === len) && arr.every(x => typeof x === "boolean");
1280}
1281function isNumberArray(arr, len) {
1282  if (Array.isArray(arr)) {
1283    return (len === null || arr.length === len) && arr.every(x => typeof x === "number");
1284  }
1285  return ArrayBuffer.isView(arr) && (arr.length === 0 || typeof arr[0] === "number") && (len === null || arr.length === len);
1286}
1287function lookupMatrix(arr, fallback) {
1288  return isNumberArray(arr, 6) ? arr : fallback;
1289}
1290function lookupRect(arr, fallback) {
1291  return isNumberArray(arr, 4) ? arr : fallback;
1292}
1293function lookupNormalRect(arr, fallback) {
1294  return isNumberArray(arr, 4) ? Util.normalizeRect(arr) : fallback;
1295}
1296function parseXFAPath(path) {
1297  const positionPattern = /(.+)\[(\d+)\]$/;
1298  return path.split(".").map(component => {
1299    const m = component.match(positionPattern);
1300    if (m) {
1301      return {
1302        name: m[1],
1303        pos: parseInt(m[2], 10)
1304      };
1305    }
1306    return {
1307      name: component,
1308      pos: 0
1309    };
1310  });
1311}
1312function escapePDFName(str) {
1313  const buffer = [];
1314  let start = 0;
1315  for (let i = 0, ii = str.length; i < ii; i++) {
1316    const char = str.charCodeAt(i);
1317    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) {
1318      if (start < i) {
1319        buffer.push(str.substring(start, i));
1320      }
1321      buffer.push(`#${char.toString(16)}`);
1322      start = i + 1;
1323    }
1324  }
1325  if (buffer.length === 0) {
1326    return str;
1327  }
1328  if (start < str.length) {
1329    buffer.push(str.substring(start, str.length));
1330  }
1331  return buffer.join("");
1332}
1333function escapeString(str) {
1334  return str.replaceAll(/([()\\\n\r])/g, match => {
1335    if (match === "\n") {
1336      return "\\n";
1337    } else if (match === "\r") {
1338      return "\\r";
1339    }
1340    return `\\${match}`;
1341  });
1342}
1343function _collectJS(entry, xref, list, parents) {
1344  if (!entry) {
1345    return;
1346  }
1347  let parent = null;
1348  if (entry instanceof Ref) {
1349    if (parents.has(entry)) {
1350      return;
1351    }
1352    parent = entry;
1353    parents.put(parent);
1354    entry = xref.fetch(entry);
1355  }
1356  if (Array.isArray(entry)) {
1357    for (const element of entry) {
1358      _collectJS(element, xref, list, parents);
1359    }
1360  } else if (entry instanceof Dict) {
1361    if (isName(entry.get("S"), "JavaScript")) {
1362      const js = entry.get("JS");
1363      let code;
1364      if (js instanceof BaseStream) {
1365        code = js.getString();
1366      } else if (typeof js === "string") {
1367        code = js;
1368      }
1369      code &&= stringToPDFString(code).replaceAll("\x00", "");
1370      if (code) {
1371        list.push(code);
1372      }
1373    }
1374    _collectJS(entry.getRaw("Next"), xref, list, parents);
1375  }
1376  if (parent) {
1377    parents.remove(parent);
1378  }
1379}
1380function collectActions(xref, dict, eventType) {
1381  const actions = Object.create(null);
1382  const additionalActionsDicts = getInheritableProperty({
1383    dict,
1384    key: "AA",
1385    stopWhenFound: false
1386  });
1387  if (additionalActionsDicts) {
1388    for (let i = additionalActionsDicts.length - 1; i >= 0; i--) {
1389      const additionalActions = additionalActionsDicts[i];
1390      if (!(additionalActions instanceof Dict)) {
1391        continue;
1392      }
1393      for (const key of additionalActions.getKeys()) {
1394        const action = eventType[key];
1395        if (!action) {
1396          continue;
1397        }
1398        const actionDict = additionalActions.getRaw(key);
1399        const parents = new RefSet();
1400        const list = [];
1401        _collectJS(actionDict, xref, list, parents);
1402        if (list.length > 0) {
1403          actions[action] = list;
1404        }
1405      }
1406    }
1407  }
1408  if (dict.has("A")) {
1409    const actionDict = dict.get("A");
1410    const parents = new RefSet();
1411    const list = [];
1412    _collectJS(actionDict, xref, list, parents);
1413    if (list.length > 0) {
1414      actions.Action = list;
1415    }
1416  }
1417  return objectSize(actions) > 0 ? actions : null;
1418}
1419const XMLEntities = {
1420  0x3c: "&lt;",
1421  0x3e: "&gt;",
1422  0x26: "&amp;",
1423  0x22: "&quot;",
1424  0x27: "&apos;"
1425};
1426function* codePointIter(str) {
1427  for (let i = 0, ii = str.length; i < ii; i++) {
1428    const char = str.codePointAt(i);
1429    if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1430      i++;
1431    }
1432    yield char;
1433  }
1434}
1435function encodeToXmlString(str) {
1436  const buffer = [];
1437  let start = 0;
1438  for (let i = 0, ii = str.length; i < ii; i++) {
1439    const char = str.codePointAt(i);
1440    if (0x20 <= char && char <= 0x7e) {
1441      const entity = XMLEntities[char];
1442      if (entity) {
1443        if (start < i) {
1444          buffer.push(str.substring(start, i));
1445        }
1446        buffer.push(entity);
1447        start = i + 1;
1448      }
1449    } else {
1450      if (start < i) {
1451        buffer.push(str.substring(start, i));
1452      }
1453      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
1454      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1455        i++;
1456      }
1457      start = i + 1;
1458    }
1459  }
1460  if (buffer.length === 0) {
1461    return str;
1462  }
1463  if (start < str.length) {
1464    buffer.push(str.substring(start, str.length));
1465  }
1466  return buffer.join("");
1467}
1468function validateFontName(fontFamily, mustWarn = false) {
1469  const m = /^("|').*("|')$/.exec(fontFamily);
1470  if (m && m[1] === m[2]) {
1471    const re = new RegExp(`[^\\\\]${m[1]}`);
1472    if (re.test(fontFamily.slice(1, -1))) {
1473      if (mustWarn) {
1474        warn(`FontFamily contains unescaped ${m[1]}: ${fontFamily}.`);
1475      }
1476      return false;
1477    }
1478  } else {
1479    for (const ident of fontFamily.split(/[ \t]+/)) {
1480      if (/^(\d|(-(\d|-)))/.test(ident) || !/^[\w-\\]+$/.test(ident)) {
1481        if (mustWarn) {
1482          warn(`FontFamily contains invalid <custom-ident>: ${fontFamily}.`);
1483        }
1484        return false;
1485      }
1486    }
1487  }
1488  return true;
1489}
1490function validateCSSFont(cssFontInfo) {
1491  const DEFAULT_CSS_FONT_OBLIQUE = "14";
1492  const DEFAULT_CSS_FONT_WEIGHT = "400";
1493  const CSS_FONT_WEIGHT_VALUES = new Set(["100", "200", "300", "400", "500", "600", "700", "800", "900", "1000", "normal", "bold", "bolder", "lighter"]);
1494  const {
1495    fontFamily,
1496    fontWeight,
1497    italicAngle
1498  } = cssFontInfo;
1499  if (!validateFontName(fontFamily, true)) {
1500    return false;
1501  }
1502  const weight = fontWeight ? fontWeight.toString() : "";
1503  cssFontInfo.fontWeight = CSS_FONT_WEIGHT_VALUES.has(weight) ? weight : DEFAULT_CSS_FONT_WEIGHT;
1504  const angle = parseFloat(italicAngle);
1505  cssFontInfo.italicAngle = isNaN(angle) || angle < -90 || angle > 90 ? DEFAULT_CSS_FONT_OBLIQUE : italicAngle.toString();
1506  return true;
1507}
1508function recoverJsURL(str) {
1509  const URL_OPEN_METHODS = ["app.launchURL", "window.open", "xfa.host.gotoURL"];
1510  const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").replaceAll(".", "\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
1511  const jsUrl = regex.exec(str);
1512  if (jsUrl?.[2]) {
1513    return {
1514      url: jsUrl[2],
1515      newWindow: jsUrl[1] === "app.launchURL" && jsUrl[3] === "true"
1516    };
1517  }
1518  return null;
1519}
1520function numberToString(value) {
1521  if (Number.isInteger(value)) {
1522    return value.toString();
1523  }
1524  const roundedValue = Math.round(value * 100);
1525  if (roundedValue % 100 === 0) {
1526    return (roundedValue / 100).toString();
1527  }
1528  if (roundedValue % 10 === 0) {
1529    return value.toFixed(1);
1530  }
1531  return value.toFixed(2);
1532}
1533function getNewAnnotationsMap(annotationStorage) {
1534  if (!annotationStorage) {
1535    return null;
1536  }
1537  const newAnnotationsByPage = new Map();
1538  for (const [key, value] of annotationStorage) {
1539    if (!key.startsWith(AnnotationEditorPrefix)) {
1540      continue;
1541    }
1542    let annotations = newAnnotationsByPage.get(value.pageIndex);
1543    if (!annotations) {
1544      annotations = [];
1545      newAnnotationsByPage.set(value.pageIndex, annotations);
1546    }
1547    annotations.push(value);
1548  }
1549  return newAnnotationsByPage.size > 0 ? newAnnotationsByPage : null;
1550}
1551function stringToAsciiOrUTF16BE(str) {
1552  return isAscii(str) ? str : stringToUTF16String(str, true);
1553}
1554function isAscii(str) {
1555  return /^[\x00-\x7F]*$/.test(str);
1556}
1557function stringToUTF16HexString(str) {
1558  const buf = [];
1559  for (let i = 0, ii = str.length; i < ii; i++) {
1560    const char = str.charCodeAt(i);
1561    buf.push(hexNumbers[char >> 8 & 0xff], hexNumbers[char & 0xff]);
1562  }
1563  return buf.join("");
1564}
1565function stringToUTF16String(str, bigEndian = false) {
1566  const buf = [];
1567  if (bigEndian) {
1568    buf.push("\xFE\xFF");
1569  }
1570  for (let i = 0, ii = str.length; i < ii; i++) {
1571    const char = str.charCodeAt(i);
1572    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1573  }
1574  return buf.join("");
1575}
1576function getRotationMatrix(rotation, width, height) {
1577  switch (rotation) {
1578    case 90:
1579      return [0, 1, -1, 0, width, 0];
1580    case 180:
1581      return [-1, 0, 0, -1, width, height];
1582    case 270:
1583      return [0, -1, 1, 0, 0, height];
1584    default:
1585      throw new Error("Invalid rotation");
1586  }
1587}
1588function getSizeInBytes(x) {
1589  return Math.ceil(Math.ceil(Math.log2(1 + x)) / 8);
1590}
1591
1592;// ./src/core/stream.js
1593
1594
1595class Stream extends BaseStream {
1596  constructor(arrayBuffer, start, length, dict) {
1597    super();
1598    this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
1599    this.start = start || 0;
1600    this.pos = this.start;
1601    this.end = start + length || this.bytes.length;
1602    this.dict = dict;
1603  }
1604  get length() {
1605    return this.end - this.start;
1606  }
1607  get isEmpty() {
1608    return this.length === 0;
1609  }
1610  getByte() {
1611    if (this.pos >= this.end) {
1612      return -1;
1613    }
1614    return this.bytes[this.pos++];
1615  }
1616  getBytes(length) {
1617    const bytes = this.bytes;
1618    const pos = this.pos;
1619    const strEnd = this.end;
1620    if (!length) {
1621      return bytes.subarray(pos, strEnd);
1622    }
1623    let end = pos + length;
1624    if (end > strEnd) {
1625      end = strEnd;
1626    }
1627    this.pos = end;
1628    return bytes.subarray(pos, end);
1629  }
1630  getByteRange(begin, end) {
1631    if (begin < 0) {
1632      begin = 0;
1633    }
1634    if (end > this.end) {
1635      end = this.end;
1636    }
1637    return this.bytes.subarray(begin, end);
1638  }
1639  reset() {
1640    this.pos = this.start;
1641  }
1642  moveStart() {
1643    this.start = this.pos;
1644  }
1645  makeSubStream(start, length, dict = null) {
1646    return new Stream(this.bytes.buffer, start, length, dict);
1647  }
1648}
1649class StringStream extends Stream {
1650  constructor(str) {
1651    super(stringToBytes(str));
1652  }
1653}
1654class NullStream extends Stream {
1655  constructor() {
1656    super(new Uint8Array(0));
1657  }
1658}
1659
1660;// ./src/core/chunked_stream.js

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

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

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