@chialab/pdfjs-lib 1.0.0-alpha.29 → 1.0.0-alpha.30

package/dist/browser/{chunk-W35PJZ6L.js → chunk-R7G44NYV.js}

@@ -2,7 +2,8 @@ import {
   __privateAdd,
   __privateGet,
   __privateMethod,
-  __privateSet
+  __privateSet,
+  __publicField
 } from "./chunk-7YYVRRNF.js";
 
 // src/lib/polyfills.ts
@@ -348,12 +349,12 @@ function getVerbosityLevel() {
 }
 function info(msg) {
   if (verbosity >= VerbosityLevel.INFOS) {
-    console.log(`Info: ${msg}`);
+    console.info(`Info: ${msg}`);
   }
 }
 function warn(msg) {
   if (verbosity >= VerbosityLevel.WARNINGS) {
-    console.log(`Warning: ${msg}`);
+    console.warn(`Warning: ${msg}`);
   }
 }
 function unreachable(msg) {
@@ -1658,6 +1659,522 @@ deleteStreamController_fn = async function(streamController, streamId) {
   delete this.streamControllers[streamId];
 };
 
+// src/pdf.js/src/shared/obj-bin-transform.js
+var _buffer, _view, _decoder, _CssFontInfo_instances, readString_fn;
+var _CssFontInfo = class _CssFontInfo {
+  constructor(buffer) {
+    __privateAdd(this, _CssFontInfo_instances);
+    __privateAdd(this, _buffer);
+    __privateAdd(this, _view);
+    __privateAdd(this, _decoder);
+    __privateSet(this, _buffer, buffer);
+    __privateSet(this, _view, new DataView(__privateGet(this, _buffer)));
+    __privateSet(this, _decoder, new TextDecoder());
+  }
+  static write(info2) {
+    const encoder = new TextEncoder();
+    const encodedStrings = {};
+    let stringsLength = 0;
+    for (const prop of _CssFontInfo.strings) {
+      const encoded = encoder.encode(info2[prop]);
+      encodedStrings[prop] = encoded;
+      stringsLength += 4 + encoded.length;
+    }
+    const buffer = new ArrayBuffer(stringsLength);
+    const data = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    let offset = 0;
+    for (const prop of _CssFontInfo.strings) {
+      const encoded = encodedStrings[prop];
+      const length = encoded.length;
+      view.setUint32(offset, length);
+      data.set(encoded, offset + 4);
+      offset += 4 + length;
+    }
+    assert(offset === buffer.byteLength, "CssFontInfo.write: Buffer overflow");
+    return buffer;
+  }
+  get fontFamily() {
+    return __privateMethod(this, _CssFontInfo_instances, readString_fn).call(this, 0);
+  }
+  get fontWeight() {
+    return __privateMethod(this, _CssFontInfo_instances, readString_fn).call(this, 1);
+  }
+  get italicAngle() {
+    return __privateMethod(this, _CssFontInfo_instances, readString_fn).call(this, 2);
+  }
+};
+_buffer = new WeakMap();
+_view = new WeakMap();
+_decoder = new WeakMap();
+_CssFontInfo_instances = new WeakSet();
+readString_fn = function(index) {
+  assert(index < _CssFontInfo.strings.length, "Invalid string index");
+  let offset = 0;
+  for (let i = 0; i < index; i++) {
+    offset += __privateGet(this, _view).getUint32(offset) + 4;
+  }
+  const length = __privateGet(this, _view).getUint32(offset);
+  return __privateGet(this, _decoder).decode(
+    new Uint8Array(__privateGet(this, _buffer), offset + 4, length)
+  );
+};
+__publicField(_CssFontInfo, "strings", ["fontFamily", "fontWeight", "italicAngle"]);
+var CssFontInfo = _CssFontInfo;
+var _buffer2, _view2, _decoder2, _SystemFontInfo_instances, readString_fn2;
+var _SystemFontInfo = class _SystemFontInfo {
+  constructor(buffer) {
+    __privateAdd(this, _SystemFontInfo_instances);
+    __privateAdd(this, _buffer2);
+    __privateAdd(this, _view2);
+    __privateAdd(this, _decoder2);
+    __privateSet(this, _buffer2, buffer);
+    __privateSet(this, _view2, new DataView(__privateGet(this, _buffer2)));
+    __privateSet(this, _decoder2, new TextDecoder());
+  }
+  static write(info2) {
+    const encoder = new TextEncoder();
+    const encodedStrings = {};
+    let stringsLength = 0;
+    for (const prop of _SystemFontInfo.strings) {
+      const encoded = encoder.encode(info2[prop]);
+      encodedStrings[prop] = encoded;
+      stringsLength += 4 + encoded.length;
+    }
+    stringsLength += 4;
+    let encodedStyleStyle, encodedStyleWeight, lengthEstimate = 1 + stringsLength;
+    if (info2.style) {
+      encodedStyleStyle = encoder.encode(info2.style.style);
+      encodedStyleWeight = encoder.encode(info2.style.weight);
+      lengthEstimate += 4 + encodedStyleStyle.length + 4 + encodedStyleWeight.length;
+    }
+    const buffer = new ArrayBuffer(lengthEstimate);
+    const data = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    let offset = 0;
+    view.setUint8(offset++, info2.guessFallback ? 1 : 0);
+    view.setUint32(offset, 0);
+    offset += 4;
+    stringsLength = 0;
+    for (const prop of _SystemFontInfo.strings) {
+      const encoded = encodedStrings[prop];
+      const length = encoded.length;
+      stringsLength += 4 + length;
+      view.setUint32(offset, length);
+      data.set(encoded, offset + 4);
+      offset += 4 + length;
+    }
+    view.setUint32(offset - stringsLength - 4, stringsLength);
+    if (info2.style) {
+      view.setUint32(offset, encodedStyleStyle.length);
+      data.set(encodedStyleStyle, offset + 4);
+      offset += 4 + encodedStyleStyle.length;
+      view.setUint32(offset, encodedStyleWeight.length);
+      data.set(encodedStyleWeight, offset + 4);
+      offset += 4 + encodedStyleWeight.length;
+    }
+    assert(
+      offset <= buffer.byteLength,
+      "SubstitionInfo.write: Buffer overflow"
+    );
+    return buffer.transferToFixedLength(offset);
+  }
+  get guessFallback() {
+    return __privateGet(this, _view2).getUint8(0) !== 0;
+  }
+  get css() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 0);
+  }
+  get loadedName() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 1);
+  }
+  get baseFontName() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 2);
+  }
+  get src() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 3);
+  }
+  get style() {
+    let offset = 1;
+    offset += 4 + __privateGet(this, _view2).getUint32(offset);
+    const styleLength = __privateGet(this, _view2).getUint32(offset);
+    const style = __privateGet(this, _decoder2).decode(
+      new Uint8Array(__privateGet(this, _buffer2), offset + 4, styleLength)
+    );
+    offset += 4 + styleLength;
+    const weightLength = __privateGet(this, _view2).getUint32(offset);
+    const weight = __privateGet(this, _decoder2).decode(
+      new Uint8Array(__privateGet(this, _buffer2), offset + 4, weightLength)
+    );
+    return { style, weight };
+  }
+};
+_buffer2 = new WeakMap();
+_view2 = new WeakMap();
+_decoder2 = new WeakMap();
+_SystemFontInfo_instances = new WeakSet();
+readString_fn2 = function(index) {
+  assert(index < _SystemFontInfo.strings.length, "Invalid string index");
+  let offset = 5;
+  for (let i = 0; i < index; i++) {
+    offset += __privateGet(this, _view2).getUint32(offset) + 4;
+  }
+  const length = __privateGet(this, _view2).getUint32(offset);
+  return __privateGet(this, _decoder2).decode(
+    new Uint8Array(__privateGet(this, _buffer2), offset + 4, length)
+  );
+};
+__publicField(_SystemFontInfo, "strings", ["css", "loadedName", "baseFontName", "src"]);
+var SystemFontInfo = _SystemFontInfo;
+var _OFFSET_NUMBERS, _OFFSET_BBOX, _OFFSET_FONT_MATRIX, _OFFSET_DEFAULT_VMETRICS, _OFFSET_STRINGS, _buffer3, _decoder3, _view3, _FontInfo_instances, readBoolean_fn, readNumber_fn, readString_fn3;
+var _FontInfo = class _FontInfo {
+  constructor({ data, extra }) {
+    __privateAdd(this, _FontInfo_instances);
+    __privateAdd(this, _buffer3);
+    __privateAdd(this, _decoder3);
+    __privateAdd(this, _view3);
+    __privateSet(this, _buffer3, data);
+    __privateSet(this, _decoder3, new TextDecoder());
+    __privateSet(this, _view3, new DataView(__privateGet(this, _buffer3)));
+    if (extra) {
+      Object.assign(this, extra);
+    }
+  }
+  get black() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 0);
+  }
+  get bold() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 1);
+  }
+  get disableFontFace() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 2);
+  }
+  get fontExtraProperties() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 3);
+  }
+  get isInvalidPDFjsFont() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 4);
+  }
+  get isType3Font() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 5);
+  }
+  get italic() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 6);
+  }
+  get missingFile() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 7);
+  }
+  get remeasure() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 8);
+  }
+  get vertical() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 9);
+  }
+  get ascent() {
+    return __privateMethod(this, _FontInfo_instances, readNumber_fn).call(this, 0);
+  }
+  get defaultWidth() {
+    return __privateMethod(this, _FontInfo_instances, readNumber_fn).call(this, 1);
+  }
+  get descent() {
+    return __privateMethod(this, _FontInfo_instances, readNumber_fn).call(this, 2);
+  }
+  get bbox() {
+    let offset = __privateGet(_FontInfo, _OFFSET_BBOX);
+    const numCoords = __privateGet(this, _view3).getUint8(offset);
+    if (numCoords === 0) {
+      return void 0;
+    }
+    offset += 1;
+    const bbox = [];
+    for (let i = 0; i < 4; i++) {
+      bbox.push(__privateGet(this, _view3).getInt16(offset, true));
+      offset += 2;
+    }
+    return bbox;
+  }
+  get fontMatrix() {
+    let offset = __privateGet(_FontInfo, _OFFSET_FONT_MATRIX);
+    const numPoints = __privateGet(this, _view3).getUint8(offset);
+    if (numPoints === 0) {
+      return void 0;
+    }
+    offset += 1;
+    const fontMatrix = [];
+    for (let i = 0; i < 6; i++) {
+      fontMatrix.push(__privateGet(this, _view3).getFloat64(offset, true));
+      offset += 8;
+    }
+    return fontMatrix;
+  }
+  get defaultVMetrics() {
+    let offset = __privateGet(_FontInfo, _OFFSET_DEFAULT_VMETRICS);
+    const numMetrics = __privateGet(this, _view3).getUint8(offset);
+    if (numMetrics === 0) {
+      return void 0;
+    }
+    offset += 1;
+    const defaultVMetrics = [];
+    for (let i = 0; i < 3; i++) {
+      defaultVMetrics.push(__privateGet(this, _view3).getInt16(offset, true));
+      offset += 2;
+    }
+    return defaultVMetrics;
+  }
+  get fallbackName() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 0);
+  }
+  get loadedName() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 1);
+  }
+  get mimetype() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 2);
+  }
+  get name() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 3);
+  }
+  get data() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + systemFontInfoLength;
+    const cssFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + cssFontInfoLength;
+    const length = __privateGet(this, _view3).getUint32(offset);
+    if (length === 0) {
+      return void 0;
+    }
+    return new Uint8Array(__privateGet(this, _buffer3), offset + 4, length);
+  }
+  clearData() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + systemFontInfoLength;
+    const cssFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + cssFontInfoLength;
+    const length = __privateGet(this, _view3).getUint32(offset);
+    const data = new Uint8Array(__privateGet(this, _buffer3), offset + 4, length);
+    data.fill(0);
+    __privateGet(this, _view3).setUint32(offset, 0);
+  }
+  get cssFontInfo() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + systemFontInfoLength;
+    const cssFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    if (cssFontInfoLength === 0) {
+      return null;
+    }
+    const cssFontInfoData = new Uint8Array(cssFontInfoLength);
+    cssFontInfoData.set(
+      new Uint8Array(__privateGet(this, _buffer3), offset + 4, cssFontInfoLength)
+    );
+    return new CssFontInfo(cssFontInfoData.buffer);
+  }
+  get systemFontInfo() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    if (systemFontInfoLength === 0) {
+      return null;
+    }
+    const systemFontInfoData = new Uint8Array(systemFontInfoLength);
+    systemFontInfoData.set(
+      new Uint8Array(__privateGet(this, _buffer3), offset + 4, systemFontInfoLength)
+    );
+    return new SystemFontInfo(systemFontInfoData.buffer);
+  }
+  static write(font) {
+    const systemFontInfoBuffer = font.systemFontInfo ? SystemFontInfo.write(font.systemFontInfo) : null;
+    const cssFontInfoBuffer = font.cssFontInfo ? CssFontInfo.write(font.cssFontInfo) : null;
+    const encoder = new TextEncoder();
+    const encodedStrings = {};
+    let stringsLength = 0;
+    for (const prop of _FontInfo.strings) {
+      encodedStrings[prop] = encoder.encode(font[prop]);
+      stringsLength += 4 + encodedStrings[prop].length;
+    }
+    const lengthEstimate = __privateGet(_FontInfo, _OFFSET_STRINGS) + 4 + stringsLength + 4 + (systemFontInfoBuffer ? systemFontInfoBuffer.byteLength : 0) + 4 + (cssFontInfoBuffer ? cssFontInfoBuffer.byteLength : 0) + 4 + (font.data ? font.data.length : 0);
+    const buffer = new ArrayBuffer(lengthEstimate);
+    const data = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    let offset = 0;
+    const numBools = _FontInfo.bools.length;
+    let boolByte = 0, boolBit = 0;
+    for (let i = 0; i < numBools; i++) {
+      const value = font[_FontInfo.bools[i]];
+      const bits = value === void 0 ? 0 : value ? 2 : 1;
+      boolByte |= bits << boolBit;
+      boolBit += 2;
+      if (boolBit === 8 || i === numBools - 1) {
+        view.setUint8(offset++, boolByte);
+        boolByte = 0;
+        boolBit = 0;
+      }
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_NUMBERS),
+      "FontInfo.write: Boolean properties offset mismatch"
+    );
+    for (const prop of _FontInfo.numbers) {
+      view.setFloat64(offset, font[prop]);
+      offset += 8;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_BBOX),
+      "FontInfo.write: Number properties offset mismatch"
+    );
+    if (font.bbox) {
+      view.setUint8(offset++, 4);
+      for (const coord of font.bbox) {
+        view.setInt16(offset, coord, true);
+        offset += 2;
+      }
+    } else {
+      view.setUint8(offset++, 0);
+      offset += 2 * 4;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_FONT_MATRIX),
+      "FontInfo.write: BBox properties offset mismatch"
+    );
+    if (font.fontMatrix) {
+      view.setUint8(offset++, 6);
+      for (const point of font.fontMatrix) {
+        view.setFloat64(offset, point, true);
+        offset += 8;
+      }
+    } else {
+      view.setUint8(offset++, 0);
+      offset += 8 * 6;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_DEFAULT_VMETRICS),
+      "FontInfo.write: FontMatrix properties offset mismatch"
+    );
+    if (font.defaultVMetrics) {
+      view.setUint8(offset++, 1);
+      for (const metric of font.defaultVMetrics) {
+        view.setInt16(offset, metric, true);
+        offset += 2;
+      }
+    } else {
+      view.setUint8(offset++, 0);
+      offset += 3 * 2;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_STRINGS),
+      "FontInfo.write: DefaultVMetrics properties offset mismatch"
+    );
+    view.setUint32(__privateGet(_FontInfo, _OFFSET_STRINGS), 0);
+    offset += 4;
+    for (const prop of _FontInfo.strings) {
+      const encoded = encodedStrings[prop];
+      const length = encoded.length;
+      view.setUint32(offset, length);
+      data.set(encoded, offset + 4);
+      offset += 4 + length;
+    }
+    view.setUint32(
+      __privateGet(_FontInfo, _OFFSET_STRINGS),
+      offset - __privateGet(_FontInfo, _OFFSET_STRINGS) - 4
+    );
+    if (!systemFontInfoBuffer) {
+      view.setUint32(offset, 0);
+      offset += 4;
+    } else {
+      const length = systemFontInfoBuffer.byteLength;
+      view.setUint32(offset, length);
+      assert(
+        offset + 4 + length <= buffer.byteLength,
+        "FontInfo.write: Buffer overflow at systemFontInfo"
+      );
+      data.set(new Uint8Array(systemFontInfoBuffer), offset + 4);
+      offset += 4 + length;
+    }
+    if (!cssFontInfoBuffer) {
+      view.setUint32(offset, 0);
+      offset += 4;
+    } else {
+      const length = cssFontInfoBuffer.byteLength;
+      view.setUint32(offset, length);
+      assert(
+        offset + 4 + length <= buffer.byteLength,
+        "FontInfo.write: Buffer overflow at cssFontInfo"
+      );
+      data.set(new Uint8Array(cssFontInfoBuffer), offset + 4);
+      offset += 4 + length;
+    }
+    if (font.data === void 0) {
+      view.setUint32(offset, 0);
+      offset += 4;
+    } else {
+      view.setUint32(offset, font.data.length);
+      data.set(font.data, offset + 4);
+      offset += 4 + font.data.length;
+    }
+    assert(offset <= buffer.byteLength, "FontInfo.write: Buffer overflow");
+    return buffer.transferToFixedLength(offset);
+  }
+};
+_OFFSET_NUMBERS = new WeakMap();
+_OFFSET_BBOX = new WeakMap();
+_OFFSET_FONT_MATRIX = new WeakMap();
+_OFFSET_DEFAULT_VMETRICS = new WeakMap();
+_OFFSET_STRINGS = new WeakMap();
+_buffer3 = new WeakMap();
+_decoder3 = new WeakMap();
+_view3 = new WeakMap();
+_FontInfo_instances = new WeakSet();
+readBoolean_fn = function(index) {
+  assert(index < _FontInfo.bools.length, "Invalid boolean index");
+  const byteOffset = Math.floor(index / 4);
+  const bitOffset = index * 2 % 8;
+  const value = __privateGet(this, _view3).getUint8(byteOffset) >> bitOffset & 3;
+  return value === 0 ? void 0 : value === 2;
+};
+readNumber_fn = function(index) {
+  assert(index < _FontInfo.numbers.length, "Invalid number index");
+  return __privateGet(this, _view3).getFloat64(__privateGet(_FontInfo, _OFFSET_NUMBERS) + index * 8);
+};
+readString_fn3 = function(index) {
+  assert(index < _FontInfo.strings.length, "Invalid string index");
+  let offset = __privateGet(_FontInfo, _OFFSET_STRINGS) + 4;
+  for (let i = 0; i < index; i++) {
+    offset += __privateGet(this, _view3).getUint32(offset) + 4;
+  }
+  const length = __privateGet(this, _view3).getUint32(offset);
+  const stringData = new Uint8Array(length);
+  stringData.set(new Uint8Array(__privateGet(this, _buffer3), offset + 4, length));
+  return __privateGet(this, _decoder3).decode(stringData);
+};
+__publicField(_FontInfo, "bools", [
+  "black",
+  "bold",
+  "disableFontFace",
+  "fontExtraProperties",
+  "isInvalidPDFjsFont",
+  "isType3Font",
+  "italic",
+  "missingFile",
+  "remeasure",
+  "vertical"
+]);
+__publicField(_FontInfo, "numbers", ["ascent", "defaultWidth", "descent"]);
+__publicField(_FontInfo, "strings", ["fallbackName", "loadedName", "mimetype", "name"]);
+__privateAdd(_FontInfo, _OFFSET_NUMBERS, Math.ceil(_FontInfo.bools.length * 2 / 8));
+__privateAdd(_FontInfo, _OFFSET_BBOX, __privateGet(_FontInfo, _OFFSET_NUMBERS) + _FontInfo.numbers.length * 8);
+__privateAdd(_FontInfo, _OFFSET_FONT_MATRIX, __privateGet(_FontInfo, _OFFSET_BBOX) + 1 + 2 * 4);
+__privateAdd(_FontInfo, _OFFSET_DEFAULT_VMETRICS, __privateGet(_FontInfo, _OFFSET_FONT_MATRIX) + 1 + 8 * 6);
+__privateAdd(_FontInfo, _OFFSET_STRINGS, __privateGet(_FontInfo, _OFFSET_DEFAULT_VMETRICS) + 1 + 2 * 3);
+var FontInfo = _FontInfo;
+
 // src/pdf.js/src/shared/scripting_utils.js
 function makeColorComp(n) {
   return Math.floor(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0");
@@ -2001,6 +2518,7 @@ export {
   convertToRGBA,
   convertBlackAndWhiteToRGBA,
   grayToRGBA,
+  FontInfo,
   ColorConverters,
   DateFormats,
   TimeFormats