@chialab/pdfjs-lib 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/pdf.js/src/core/colorspace_utils.d.ts

@@ -0,0 +1,21 @@
+export class ColorSpaceUtils {
+    static parse({ cs, xref, resources, pdfFunctionFactory, globalColorSpaceCache, localColorSpaceCache, asyncIfNotCached, }: {
+        cs: any;
+        xref: any;
+        resources?: null | undefined;
+        pdfFunctionFactory: any;
+        globalColorSpaceCache: any;
+        localColorSpaceCache: any;
+        asyncIfNotCached?: boolean | undefined;
+    }): any;
+    /**
+     * NOTE: This method should *only* be invoked from `this.#parse`,
+     *       when parsing "sub" ColorSpaces.
+     */
+    static "__#private@#subParse"(cs: any, options: any): any;
+    static "__#private@#parse"(cs: any, options: any): any;
+    static get gray(): any;
+    static get rgb(): any;
+    static get rgba(): any;
+    static get cmyk(): any;
+}

package/dist/pdf.js/src/core/core_utils.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Combines multiple ArrayBuffers into a single Uint8Array.
+ * @param {Array<ArrayBuffer>} arr - An array of ArrayBuffers.
+ * @returns {Uint8Array}
+ */
+export function arrayBuffersToBytes(arr: Array<ArrayBuffer>): Uint8Array;
+export function codePointIter(str: any): Generator<any, void, unknown>;
+export function collectActions(xref: any, dict: any, eventType: any): any;
+export function encodeToXmlString(str: any): any;
+export function escapePDFName(str: any): any;
+export function escapeString(str: any): any;
+export function fetchBinaryData(url: any): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * Get the value of an inheritable property.
+ *
+ * If the PDF specification explicitly lists a property in a dictionary as
+ * inheritable, then the value of the property may be present in the dictionary
+ * itself or in one or more parents of the dictionary.
+ *
+ * If the key is not found in the tree, `undefined` is returned. Otherwise,
+ * the value for the key is returned or, if `stopWhenFound` is `false`, a list
+ * of values is returned.
+ *
+ * @param {Dict} dict - Dictionary from where to start the traversal.
+ * @param {string} key - The key of the property to find the value for.
+ * @param {boolean} getArray - Whether or not the value should be fetched as an
+ *   array. The default value is `false`.
+ * @param {boolean} stopWhenFound - Whether or not to stop the traversal when
+ *   the key is found. If set to `false`, we always walk up the entire parent
+ *   chain, for example to be able to find `\Resources` placed on multiple
+ *   levels of the tree. The default value is `true`.
+ */
+export function getInheritableProperty({ dict, key, getArray, stopWhenFound, }: Dict): any;
+export function getLookupTableFactory(initializer: any): () => any;
+export function getNewAnnotationsMap(annotationStorage: any): Map<any, any> | null;
+/**
+ * Get the parent dictionary to update when a property is set.
+ *
+ * @param {Dict} dict - Dictionary from where to start the traversal.
+ * @param {Ref} ref - The reference to the dictionary.
+ * @param {XRef} xref - The `XRef` instance.
+ */
+export function getParentToUpdate(dict: Dict, ref: Ref, xref: XRef): {
+    dict: null;
+    ref: null;
+};
+export function getRotationMatrix(rotation: any, width: any, height: any): any[];
+/**
+ * Get the number of bytes to use to represent the given positive integer.
+ * If n is zero, the function returns 0 which means that we don't need to waste
+ * a byte to represent it.
+ * @param {number} x - a positive integer.
+ * @returns {number}
+ */
+export function getSizeInBytes(x: number): number;
+export const IDENTITY_MATRIX: number[];
+export function isAscii(str: any): boolean;
+/**
+ * Checks if something is an Array containing only boolean values,
+ * and (optionally) checks its length.
+ * @param {any} arr
+ * @param {number | null} len
+ * @returns {boolean}
+ */
+export function isBooleanArray(arr: any, len: number | null): boolean;
+/**
+ * Checks if something is an Array containing only numbers,
+ * and (optionally) checks its length.
+ * @param {any} arr
+ * @param {number | null} len
+ * @returns {boolean}
+ */
+export function isNumberArray(arr: any, len: number | null): boolean;
+export function isWhiteSpace(ch: any): boolean;
+export function log2(x: any): number;
+export function lookupMatrix(arr: any, fallback: any): any;
+export function lookupNormalRect(arr: any, fallback: any): any;
+export function lookupRect(arr: any, fallback: any): any;
+export const MAX_INT_32: number;
+export const MIN_INT_32: number;
+declare const MissingDataException_base: any;
+export class MissingDataException extends MissingDataException_base {
+    [x: string]: any;
+    constructor(begin: any, end: any);
+    begin: any;
+    end: any;
+}
+export function numberToString(value: any): any;
+declare const ParserEOFException_base: any;
+export class ParserEOFException extends ParserEOFException_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+/**
+ * AcroForm field names use an array like notation to refer to
+ * repeated XFA elements e.g. foo.bar[nnn].
+ * see: XFA Spec Chapter 3 - Repeated Elements
+ *
+ * @param {string} path - XFA path name.
+ * @returns {Array} - Array of Objects with the name and pos of
+ * each part of the path.
+ */
+export function parseXFAPath(path: string): any[];
+export const PDF_VERSION_REGEXP: RegExp;
+export function readInt16(data: any, offset: any): number;
+export function readInt8(data: any, offset: any): number;
+export function readUint16(data: any, offset: any): number;
+export function readUint32(data: any, offset: any): number;
+export function recoverJsURL(str: any): {
+    url: string;
+    newWindow: boolean;
+} | null;
+export const RESOURCES_KEYS_OPERATOR_LIST: string[];
+export const RESOURCES_KEYS_TEXT_CONTENT: string[];
+export function stringToAsciiOrUTF16BE(str: any): any;
+export function stringToUTF16HexString(str: any): string;
+export function stringToUTF16String(str: any, bigEndian?: boolean): string;
+/**
+ * Converts positive integers to (upper case) Roman numerals.
+ * @param {number} number - The number that should be converted.
+ * @param {boolean} lowerCase - Indicates if the result should be converted
+ *   to lower case letters. The default value is `false`.
+ * @returns {string} The resulting Roman number.
+ */
+export function toRomanNumerals(number: number, lowerCase?: boolean): string;
+export function validateCSSFont(cssFontInfo: any): boolean;
+export function validateFontName(fontFamily: any, mustWarn?: boolean): boolean;
+declare const XRefEntryException_base: any;
+export class XRefEntryException extends XRefEntryException_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+declare const XRefParseException_base: any;
+export class XRefParseException extends XRefParseException_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+import { Dict } from "./primitives.js";
+import { Ref } from "./primitives.js";
+export {};

package/dist/pdf.js/src/core/decode_stream.d.ts

@@ -0,0 +1,25 @@
+export class DecodeStream extends BaseStream {
+    constructor(maybeMinBufferLength: any);
+    _rawMinBufferLength: any;
+    pos: number;
+    bufferLength: number;
+    eof: boolean;
+    buffer: Uint8Array<ArrayBuffer>;
+    minBufferLength: number;
+    get isEmpty(): boolean;
+    ensureBuffer(requested: any): Uint8Array<ArrayBuffer>;
+    getByte(): number;
+    getBytes(length: any, decoderOptions?: null): Uint8Array<ArrayBuffer>;
+    getImageData(length: any, decoderOptions: any): Promise<any>;
+    makeSubStream(start: any, length: any, dict?: null): Stream;
+    getBaseStreams(): any;
+}
+export class StreamsSequenceStream extends DecodeStream {
+    constructor(streams: any, onError?: null);
+    streams: any;
+    _onError: any;
+    readBlock(): void;
+    getBaseStreams(): any[] | null;
+}
+import { BaseStream } from "./base_stream.js";
+import { Stream } from "./stream.js";

package/dist/pdf.js/src/core/encodings.d.ts

@@ -0,0 +1,7 @@
+export const ExpertEncoding: string[];
+export function getEncoding(encodingName: any): string[] | null;
+export const MacRomanEncoding: string[];
+export const StandardEncoding: string[];
+export const SymbolSetEncoding: string[];
+export const WinAnsiEncoding: string[];
+export const ZapfDingbatsEncoding: string[];

package/dist/pdf.js/src/core/flate_stream.d.ts

@@ -0,0 +1,15 @@
+export class FlateStream extends DecodeStream {
+    constructor(str: any, maybeLength: any);
+    str: any;
+    dict: any;
+    codeSize: number;
+    codeBuf: number;
+    getImageData(length: any, _decoderOptions: any): Promise<Uint8Array<ArrayBuffer>>;
+    asyncGetBytes(): Promise<Uint8Array<ArrayBuffer> | null>;
+    getBits(bits: any): number;
+    getCode(table: any): number;
+    generateHuffmanTable(lengths: any): (number | Int32Array<ArrayBuffer>)[];
+    readBlock(): void;
+    #private;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/pdf.js/src/core/font_renderer.d.ts

@@ -0,0 +1,34 @@
+export class FontRendererFactory {
+    static create(font: any, seacAnalysisEnabled: any): TrueTypeCompiled | Type2Compiled;
+}
+declare class TrueTypeCompiled extends CompiledFont {
+    constructor(glyphs: any, cmap: any, fontMatrix: any);
+    glyphs: any;
+    cmap: any;
+    compileGlyphImpl(code: any, cmds: any): void;
+}
+declare class Type2Compiled extends CompiledFont {
+    constructor(cffInfo: any, cmap: any, fontMatrix: any);
+    glyphs: any;
+    gsubrs: any;
+    subrs: any;
+    cmap: any;
+    glyphNameMap: any;
+    gsubrsBias: number;
+    subrsBias: number;
+    isCFFCIDFont: any;
+    fdSelect: any;
+    fdArray: any;
+    compileGlyphImpl(code: any, cmds: any, glyphId: any): void;
+}
+declare class CompiledFont {
+    constructor(fontMatrix: any);
+    fontMatrix: any;
+    compiledGlyphs: any;
+    compiledCharCodeToGlyphId: any;
+    getPathJs(unicode: any): any;
+    compileGlyph(code: any, glyphId: any): string;
+    compileGlyphImpl(): void;
+    hasBuiltPath(unicode: any): boolean;
+}
+export {};

package/dist/pdf.js/src/core/fonts.d.ts

@@ -0,0 +1,98 @@
+export class ErrorFont {
+    constructor(error: any);
+    error: any;
+    loadedName: string;
+    missingFile: boolean;
+    charsToGlyphs(): never[];
+    encodeString(chars: any): any[];
+    exportData(): {
+        error: any;
+    };
+}
+/**
+ * 'Font' is the class the outside world should use, it encapsulate all the font
+ * decoding logics whatever type it is (assuming the font type is supported).
+ */
+export class Font {
+    constructor(name: any, file: any, properties: any, evaluatorOptions: any);
+    name: any;
+    psName: any;
+    mimetype: string | null;
+    disableFontFace: any;
+    fontExtraProperties: any;
+    loadedName: any;
+    isType3Font: any;
+    missingFile: boolean;
+    cssFontInfo: any;
+    _charsCache: any;
+    _glyphCache: any;
+    isSerifFont: boolean;
+    isSymbolicFont: boolean;
+    isMonospace: boolean;
+    type: any;
+    subtype: any;
+    systemFontInfo: any;
+    isInvalidPDFjsFont: boolean;
+    fallbackName: any;
+    differences: any;
+    widths: any;
+    defaultWidth: any;
+    composite: any;
+    cMap: any;
+    capHeight: number;
+    ascent: number;
+    descent: number;
+    lineHeight: number;
+    fontMatrix: any;
+    bbox: any;
+    defaultEncoding: any;
+    toUnicode: any;
+    toFontChar: any[];
+    cidEncoding: any;
+    vertical: boolean | undefined;
+    vmetrics: any;
+    defaultVMetrics: any;
+    data: Uint8Array<ArrayBuffer> | undefined;
+    seacMap: any;
+    get renderer(): any;
+    exportData(): {
+        data: any;
+        extra?: undefined;
+    } | {
+        data: any;
+        extra: any;
+    };
+    fallbackToSystemFont(properties: any): void;
+    bold: boolean | undefined;
+    italic: boolean | undefined;
+    black: boolean | undefined;
+    remeasure: boolean | undefined;
+    checkAndRepair(name: any, font: any, properties: any): Uint8Array<ArrayBuffer>;
+    isOpenType: boolean | undefined;
+    lineGap: any;
+    convert(fontName: any, font: any, properties: any): Uint8Array<ArrayBuffer>;
+    /**
+     * @private
+     */
+    private get _spaceWidth();
+    /**
+     * @private
+     */
+    private _charToGlyph;
+    charsToGlyphs(chars: any): any;
+    /**
+     * Chars can have different sizes (depends on the encoding).
+     * @param {String} a string encoded with font encoding.
+     * @returns {Array<Array<number>>} the positions of each char in the string.
+     */
+    getCharPositions(chars: any): Array<Array<number>>;
+    get glyphCacheValues(): any[];
+    /**
+     * Encode a js string using font encoding.
+     * The resulting array contains an encoded string at even positions
+     * (can be empty) and a non-encoded one at odd positions.
+     * @param {String} a js string.
+     * @returns {Array<String>} an array of encoded strings or non-encoded ones.
+     */
+    encodeString(str: any): Array<string>;
+}

package/dist/pdf.js/src/core/fonts_utils.d.ts

@@ -0,0 +1,32 @@
+export function compileType3Glyph({ data: img, width, height }: {
+    data: any;
+    width: any;
+    height: any;
+}): (number | Float32Array<ArrayBuffer> | Float32Array<ArrayBuffer>[])[] | null;
+export namespace FontFlags {
+    let FixedPitch: number;
+    let Serif: number;
+    let Symbolic: number;
+    let Script: number;
+    let Nonsymbolic: number;
+    let Italic: number;
+    let AllCap: number;
+    let SmallCap: number;
+    let ForceBold: number;
+}
+export const getVerticalPresentationForm: () => any;
+export const MacStandardGlyphOrdering: string[];
+export function normalizeFontName(name: any): any;
+export function recoverGlyphName(name: any, glyphsUnicodeMap: any): any;
+export const SEAC_ANALYSIS_ENABLED: true;
+/**
+ * Shared logic for building a char code to glyph id mapping for Type1 and
+ * simple CFF fonts. See section 9.6.6.2 of the spec.
+ * @param {Object} properties Font properties object.
+ * @param {Object} builtInEncoding The encoding contained within the actual font
+ *   data.
+ * @param {Array} glyphNames Array of glyph names where the index is the
+ *   glyph ID.
+ * @returns {Object} A char code to glyph ID map.
+ */
+export function type1FontGlyphMapping(properties: Object, builtInEncoding: Object, glyphNames: any[]): Object;

package/dist/pdf.js/src/core/glyf.d.ts

@@ -0,0 +1,44 @@
+/**
+ * GlyfTable object represents a glyf table containing glyph information:
+ *  - glyph header (xMin, yMin, xMax, yMax);
+ *  - contours if any;
+ *  - components if the glyph is a composite.
+ *
+ * It's possible to re-scale each glyph in order to have a new font which
+ * exactly fits an other one: the goal is to be able to build some substitution
+ * font for well-known fonts (Myriad, Arial, ...).
+ *
+ * A full description of glyf table can be found here
+ * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6glyf.html
+ */
+export class GlyfTable {
+    constructor({ glyfTable, isGlyphLocationsLong, locaTable, numGlyphs }: {
+        glyfTable: any;
+        isGlyphLocationsLong: any;
+        locaTable: any;
+        numGlyphs: any;
+    });
+    glyphs: Glyph[];
+    getSize(): any;
+    write(): {
+        isLocationLong: boolean;
+        loca: Uint8Array<ArrayBuffer>;
+        glyf: Uint8Array<ArrayBuffer>;
+    };
+    scale(factors: any): void;
+}
+declare class Glyph {
+    static parse(pos: any, glyf: any): Glyph;
+    constructor({ header, simple, composites }: {
+        header?: null | undefined;
+        simple?: null | undefined;
+        composites?: null | undefined;
+    });
+    header: any;
+    simple: any;
+    composites: any;
+    getSize(): any;
+    write(pos: any, buf: any): number;
+    scale(factor: any): void;
+}
+export {};

package/dist/pdf.js/src/core/glyphlist.d.ts

@@ -0,0 +1,2 @@
+export const getDingbatsGlyphsUnicode: () => any;
+export const getGlyphsUnicode: () => any;

package/dist/pdf.js/src/core/icc_colorspace.d.ts

@@ -0,0 +1,22 @@
+export class CmykICCBasedCS extends IccColorSpace {
+    static "__#private@#iccUrl": any;
+    static setOptions({ iccUrl }: {
+        iccUrl: any;
+    }): void;
+    constructor();
+}
+export class IccColorSpace extends ColorSpace {
+    static "__#private@#useWasm": boolean;
+    static "__#private@#wasmUrl": null;
+    static "__#private@#finalizer": null;
+    static setOptions({ useWasm, useWorkerFetch, wasmUrl }: {
+        useWasm: any;
+        useWorkerFetch: any;
+        wasmUrl: any;
+    }): void;
+    static get isUsable(): any;
+    constructor(iccProfile: any, name: any, numComps: any);
+    getOutputLength(inputLength: any, alpha01: any): number;
+    #private;
+}
+import { ColorSpace } from "./colorspace.js";

package/dist/pdf.js/src/core/jbig2.d.ts

@@ -0,0 +1,12 @@
+declare const Jbig2Error_base: any;
+export class Jbig2Error extends Jbig2Error_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+export class Jbig2Image {
+    parseChunks(chunks: any): Uint8ClampedArray<ArrayBuffer> | undefined;
+    parse(data: any): Uint8ClampedArray<ArrayBuffer>;
+    width: any;
+    height: any;
+}
+export {};

package/dist/pdf.js/src/core/jbig2_stream.d.ts

@@ -0,0 +1,17 @@
+/**
+ * For JBIG2's we use a library to decode these images and
+ * the stream behaves like all the other DecodeStreams.
+ */
+export class Jbig2Stream extends DecodeStream {
+    constructor(stream: any, maybeLength: any, params: any);
+    stream: any;
+    dict: any;
+    maybeLength: any;
+    params: any;
+    get bytes(): any;
+    ensureBuffer(requested: any): void;
+    readBlock(): void;
+    decodeImage(bytes: any): Uint8Array<ArrayBuffer>;
+    get canAsyncDecodeImageFromBuffer(): any;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/pdf.js/src/core/jpeg_stream.d.ts

@@ -0,0 +1,25 @@
+/**
+ * For JPEG's we use a library to decode these images and the stream behaves
+ * like all the other DecodeStreams.
+ */
+export class JpegStream extends DecodeStream {
+    static "__#private@#isImageDecoderSupported": any;
+    static get canUseImageDecoder(): any;
+    static setOptions({ isImageDecoderSupported }: {
+        isImageDecoderSupported?: boolean | undefined;
+    }): void;
+    constructor(stream: any, maybeLength: any, params: any);
+    stream: any;
+    dict: any;
+    maybeLength: any;
+    params: any;
+    get bytes(): any;
+    ensureBuffer(requested: any): void;
+    readBlock(): void;
+    get jpegOptions(): any;
+    decodeImage(bytes: any): Uint8Array<ArrayBuffer>;
+    get canAsyncDecodeImageFromBuffer(): any;
+    getTransferableImage(): Promise<VideoFrame | null>;
+    #private;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/pdf.js/src/core/jpg.d.ts

@@ -0,0 +1,62 @@
+declare const JpegError_base: any;
+export class JpegError extends JpegError_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+export class JpegImage {
+    static canUseImageDecoder(data: any, colorTransform?: number): {
+        exifStart: any;
+        exifEnd: any;
+    } | {
+        exifStart?: undefined;
+        exifEnd?: undefined;
+    } | null;
+    constructor({ decodeTransform, colorTransform }?: {
+        decodeTransform?: null | undefined;
+        colorTransform?: number | undefined;
+    });
+    _decodeTransform: any;
+    _colorTransform: number;
+    parse(data: any, { dnlScanLines }?: {
+        dnlScanLines?: null | undefined;
+    }): any;
+    width: any;
+    height: any;
+    jfif: {
+        version: {
+            major: any;
+            minor: any;
+        };
+        densityUnits: any;
+        xDensity: number;
+        yDensity: number;
+        thumbWidth: any;
+        thumbHeight: any;
+        thumbData: any;
+    } | null | undefined;
+    adobe: {
+        version: number;
+        flags0: number;
+        flags1: number;
+        transformCode: any;
+    } | null | undefined;
+    components: any[] | undefined;
+    numComponents: number | undefined;
+    _getLinearizedBlockData(width: any, height: any, isSourcePDF?: boolean): Uint8ClampedArray<ArrayBuffer>;
+    get _isColorConversionNeeded(): boolean;
+    _convertYccToRgb(data: any): any;
+    _convertYccToRgba(data: any, out: any): any;
+    _convertYcckToRgb(data: any): any;
+    _convertYcckToRgba(data: any): any;
+    _convertYcckToCmyk(data: any): any;
+    _convertCmykToRgb(data: any): any;
+    _convertCmykToRgba(data: any): any;
+    getData({ width, height, forceRGBA, forceRGB, isSourcePDF, }: {
+        width: any;
+        height: any;
+        forceRGBA?: boolean | undefined;
+        forceRGB?: boolean | undefined;
+        isSourcePDF?: boolean | undefined;
+    }): any;
+}
+export {};

package/dist/pdf.js/src/core/jpx.d.ts

@@ -0,0 +1,35 @@
+declare const JpxError_base: any;
+export class JpxError extends JpxError_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+export class JpxImage {
+    static "__#private@#buffer": null;
+    static "__#private@#handler": null;
+    static "__#private@#modulePromise": null;
+    static "__#private@#useWasm": boolean;
+    static "__#private@#useWorkerFetch": boolean;
+    static "__#private@#wasmUrl": null;
+    static setOptions({ handler, useWasm, useWorkerFetch, wasmUrl }: {
+        handler: any;
+        useWasm: any;
+        useWorkerFetch: any;
+        wasmUrl: any;
+    }): void;
+    static "__#private@#getJsModule"(fallbackCallback: any): Promise<void>;
+    static "__#private@#instantiateWasm"(fallbackCallback: any, imports: any, successCallback: any): Promise<any>;
+    static decode(bytes: any, { numComponents, isIndexedColormap, smaskInData, reducePower, }?: {
+        numComponents?: number | undefined;
+        isIndexedColormap?: boolean | undefined;
+        smaskInData?: boolean | undefined;
+        reducePower?: number | undefined;
+    }): Promise<never>;
+    static cleanup(): void;
+    static parseImageProperties(stream: any): {
+        width: number;
+        height: number;
+        bitsPerComponent: number;
+        componentsCount: any;
+    };
+}
+export {};

package/dist/pdf.js/src/core/jpx_stream.d.ts

@@ -0,0 +1,17 @@
+/**
+ * For JPEG 2000's we use a library to decode these images and
+ * the stream behaves like all the other DecodeStreams.
+ */
+export class JpxStream extends DecodeStream {
+    constructor(stream: any, maybeLength: any, params: any);
+    stream: any;
+    dict: any;
+    maybeLength: any;
+    params: any;
+    get bytes(): any;
+    ensureBuffer(requested: any): void;
+    readBlock(decoderOptions: any): void;
+    decodeImage(bytes: any, decoderOptions: any): Promise<Uint8Array<ArrayBuffer>>;
+    get canAsyncDecodeImageFromBuffer(): any;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/pdf.js/src/core/lzw_stream.d.ts

@@ -0,0 +1,21 @@
+export class LZWStream extends DecodeStream {
+    constructor(str: any, maybeLength: any, earlyChange: any);
+    str: any;
+    dict: any;
+    cachedData: number;
+    bitsCached: number;
+    lzwState: {
+        earlyChange: any;
+        codeLength: number;
+        nextCode: number;
+        dictionaryValues: Uint8Array<ArrayBuffer>;
+        dictionaryLengths: Uint16Array<ArrayBuffer>;
+        dictionaryPrevCodes: Uint16Array<ArrayBuffer>;
+        currentSequence: Uint8Array<ArrayBuffer>;
+        currentSequenceLength: number;
+    };
+    readBits(n: any): number | null;
+    lastCode: any;
+    readBlock(): void;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/pdf.js/src/core/metrics.d.ts

@@ -0,0 +1,2 @@
+export const getFontBasicMetrics: () => any;
+export const getMetrics: () => any;

package/dist/pdf.js/src/core/name_number_tree.d.ts

@@ -0,0 +1,21 @@
+export class NameTree extends NameOrNumberTree {
+    constructor(root: any, xref: any);
+}
+export class NumberTree extends NameOrNumberTree {
+    constructor(root: any, xref: any);
+}
+/**
+ * A NameTree/NumberTree is like a Dict but has some advantageous properties,
+ * see the specification (7.9.6 and 7.9.7) for additional details.
+ * TODO: implement all the Dict functions and make this more efficient.
+ */
+declare class NameOrNumberTree {
+    constructor(root: any, xref: any, type: any);
+    root: any;
+    xref: any;
+    _type: any;
+    getAll(): Map<any, any>;
+    getRaw(key: any): any;
+    get(key: any): any;
+}
+export {};