unpdf 1.6.2 → 1.8.0

package/dist/types/src/core/core_utils.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 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 deepCompare(a: any, b: any): boolean;
+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 getModificationDate(date?: Date): string;
+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[];
+/**
+ * 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 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;
+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 recoverJsURL(str: any): {
+    url: string;
+    newWindow: boolean;
+} | null;
+export const RESOURCES_KEYS_OPERATOR_LIST: string[];
+export const RESOURCES_KEYS_TEXT_CONTENT: 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/types/src/core/crypto.d.ts

@@ -0,0 +1,136 @@
+export type CipherConstructors = typeof AES128Cipher | typeof AES256Cipher | typeof ARCFourCipher | typeof NullCipher;
+/**
+ * Find the appropriate cipher class based on the filter name.
+ */
+export type ResolveCipher = (filterName?: Name | null | undefined) => CipherConstructors;
+export class AES128Cipher extends AESBaseCipher {
+    constructor(key: any);
+    _rcon: Uint8Array<ArrayBuffer>;
+    _cyclesOfRepetition: number;
+    _keySize: number;
+    _key: Uint8Array<ArrayBuffer>;
+    _expandKey(cipherKey: any): Uint8Array<ArrayBuffer>;
+}
+export class AES256Cipher extends AESBaseCipher {
+    constructor(key: any);
+    _cyclesOfRepetition: number;
+    _keySize: number;
+    _key: Uint8Array<ArrayBuffer>;
+    _expandKey(cipherKey: any): Uint8Array<ArrayBuffer>;
+}
+/**
+ * @typedef {typeof AES128Cipher | typeof AES256Cipher | typeof ARCFourCipher
+ * | typeof NullCipher} CipherConstructors
+ */
+/**
+ * @callback ResolveCipher
+ *   Find the appropriate cipher class based on the filter name.
+ * @param {Name | null} [filterName]
+ *   Name.
+ * @returns {CipherConstructors}
+ *   Cipher constructor.
+ */
+export class ARCFourCipher {
+    constructor(key: any);
+    a: number;
+    b: number;
+    s: Uint8Array<ArrayBuffer>;
+    encryptBlock(data: any): Uint8Array<any>;
+    decryptBlock(data: any): Uint8Array<any>;
+    encrypt(data: any): Uint8Array<any>;
+}
+export class CipherTransform {
+    /**
+     * @param {ResolveCipher} resolveCipher
+     *   Resolve a cipher constructor from a crypt filter name.
+     * @param {Name | null} [stringFilterName]
+     *   Default crypt filter for strings.
+     * @param {Name | null} [streamFilterName]
+     *   Default crypt filter for streams.
+     */
+    constructor(resolveCipher: ResolveCipher, stringFilterName?: Name | null, streamFilterName?: Name | null);
+    /** @type {Name | null} */
+    embeddedFilterName: Name | null;
+    resolveCipher: ResolveCipher;
+    streamFilterName: Name | null;
+    stringFilterName: Name | null;
+    /**
+     * @param {BaseStream} stream
+     * @param {number | null} length
+     * @param {Name | null} [cryptFilterName]
+     * @returns {DecryptStream}
+     */
+    createStream(stream: BaseStream, length: number | null, cryptFilterName?: Name | null): DecryptStream;
+    decryptString(s: any): string;
+    encryptString(s: any): string;
+    #private;
+}
+export class CipherTransformFactory {
+    static get _defaultPasswordBytes(): any;
+    constructor(dict: any, fileId: any, password: any);
+    filterName: any;
+    dict: any;
+    algorithm: any;
+    cf: any;
+    stmf: any;
+    strf: any;
+    eff: any;
+    encryptMetadata: boolean;
+    encryptionKey: any;
+    /**
+     * Set password.
+     *
+     * @param {string} password
+     *   New password.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    setPassword(password: string): undefined;
+    /**
+     * @param {number} num
+     *   Object number.
+     * @param {number} gen
+     *   Generation number.
+     * @returns {CipherTransform}
+     *   Cipher transform.
+     */
+    createCipherTransform(num: number, gen: number): CipherTransform;
+    #private;
+}
+export class PDF17 extends PDFBase {
+    _hash(password: any, input: any, userBytes: any): Uint8Array<ArrayBuffer>;
+}
+export class PDF20 extends PDFBase {
+    _hash(password: any, input: any, userBytes: any): Uint8Array<ArrayBuffer>;
+}
+declare class NullCipher {
+    decryptBlock(data: any): any;
+    encrypt(data: any): any;
+}
+import { Name } from "./primitives.js";
+declare class AESBaseCipher {
+    _s: Uint8Array<ArrayBuffer>;
+    _inv_s: Uint8Array<ArrayBuffer>;
+    _mix: Uint32Array<ArrayBuffer>;
+    _mixCol: Uint8Array<ArrayBuffer>;
+    buffer: Uint8Array<ArrayBuffer>;
+    bufferPosition: number;
+    _expandKey(cipherKey: any): void;
+    _decrypt(input: any, key: any): Uint8Array<ArrayBuffer>;
+    _encrypt(input: any, key: any): Uint8Array<ArrayBuffer>;
+    _decryptBlock2(data: any, finalize: any): Uint8Array<ArrayBuffer>;
+    bufferLength: number | undefined;
+    iv: any;
+    decryptBlock(data: any, finalize: any, iv?: null): any;
+    encrypt(data: any, iv: any): Uint8Array<ArrayBuffer>;
+}
+import type { BaseStream } from "./base_stream.js";
+import { DecryptStream } from "./decrypt_stream.js";
+declare class PDFBase {
+    _hash(password: any, input: any, userBytes: any): void;
+    checkOwnerPassword(password: any, ownerValidationSalt: any, userBytes: any, ownerPassword: any): boolean;
+    checkUserPassword(password: any, userValidationSalt: any, userPassword: any): boolean;
+    getOwnerKey(password: any, ownerKeySalt: any, userBytes: any, ownerEncryption: any): any;
+    getUserKey(password: any, userKeySalt: any, userEncryption: any): any;
+}
+export {};

package/dist/types/src/core/decode_stream.d.ts

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

package/dist/types/src/core/decrypt_stream.d.ts

@@ -0,0 +1,9 @@
+export class DecryptStream extends DecodeStream {
+    constructor(str: any, maybeLength: any, decrypt: any);
+    stream: any;
+    dict: any;
+    decrypt: any;
+    getOriginalStream(): this;
+    #private;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/src/core/file_spec.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @import { CatalogAttachmentContent } from "./catalog.js";
+ */
+/**
+ * "A PDF file can refer to the contents of another file by using a File
+ * Specification (PDF 1.1)", see the spec (7.11) for more details.
+ * NOTE: Only embedded files are supported (as part of the attachments support)
+ * TODO: support the 'URL' file system (with caching if !/V), portable
+ * collections attributes and related files (/RF)
+ */
+export class FileSpec {
+    /**
+     * Get a platform-specific item from a file-spec dictionary.
+     *
+     * Search order follows the PDF platform keys: `UF`, `F`, `Unix`, `Mac`,
+     * `DOS`.
+     *
+     * @param {Dict | null | undefined} dict
+     *   Dictionary.
+     * @param {boolean} [raw]
+     *   Return the raw (possibly indirect) value rather than the resolved one.
+     * @returns {unknown}
+     *   Matching dictionary value or `null` when no key is found.
+     */
+    static pickPlatformItem(dict: Dict | null | undefined, raw?: boolean): unknown;
+    /**
+     * Whether a file specification carries an embedded file we can read.
+     *
+     * @param {Dict} fileSpecDict
+     * @returns {boolean}
+     */
+    static hasEmbeddedFile(fileSpecDict: Dict): boolean;
+    /**
+     * Read attachment bytes from a file-spec dictionary.
+     *
+     * @param {Dict | null | undefined} dict
+     *   File-spec dictionary containing an `EF` entry.
+     * @returns {CatalogAttachmentContent}
+     *   Attachment bytes when available; otherwise `null`.
+     * @throws {PasswordException}
+     *   When attachment bytes are encrypted and no key is available.
+     */
+    static readContent(dict: Dict | null | undefined): CatalogAttachmentContent;
+    /**
+     * Read the bytes of an embedded-file stream.
+     *
+     * @param {BaseStream} stream
+     *   Embedded-file stream.
+     * @returns {CatalogAttachmentContent}
+     *   Attachment bytes.
+     * @throws {PasswordException}
+     *   When the bytes are encrypted and no key is available.
+     */
+    static readStreamContent(stream: BaseStream): CatalogAttachmentContent;
+    /**
+     * @param {Dict | null | undefined} root
+     *   File specification dictionary.
+     */
+    constructor(root: Dict | null | undefined);
+    root: Dict | undefined;
+    fs: any;
+    get filename(): string;
+    get description(): string;
+    get serializable(): {
+        rawFilename: string;
+        filename: any;
+        description: string;
+    };
+}
+import { Dict } from "./primitives.js";
+import type { CatalogAttachmentContent } from "./catalog.js";
+import { BaseStream } from "./base_stream.js";

package/dist/types/src/core/flate_stream.d.ts

@@ -0,0 +1,14 @@
+export class FlateStream extends DecodeStream {
+    constructor(str: any, maybeLength: any);
+    stream: 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>)[];
+    #private;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/src/core/icc_colorspace.d.ts

@@ -0,0 +1,22 @@
+export class CmykICCBasedCS extends IccColorSpace {
+    static #iccUrl: any;
+    static setOptions({ iccUrl }: {
+        iccUrl: any;
+    }): void;
+    constructor();
+}
+export class IccColorSpace extends ColorSpace {
+    static #useWasm: boolean;
+    static #wasmUrl: null;
+    static #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/types/src/core/image_utils.d.ts

@@ -0,0 +1,52 @@
+export class GlobalColorSpaceCache extends BaseLocalCache {
+    set(name: null | undefined, ref: any, data: any): void;
+    clear(): void;
+}
+export class GlobalImageCache {
+    static NUM_PAGES_THRESHOLD: number;
+    static MIN_IMAGES_TO_CACHE: number;
+    static MAX_BYTE_SIZE: number;
+    _refCache: RefSetCache;
+    _imageCache: RefSetCache;
+    shouldCache(ref: any, pageIndex: any): boolean;
+    addDecodeFailed(ref: any): void;
+    hasDecodeFailed(ref: any): boolean;
+    /**
+     * PLEASE NOTE: Must be called *after* the `setData` method.
+     */
+    addByteSize(ref: any, byteSize: any): void;
+    getData(ref: any, pageIndex: any): any;
+    setData(ref: any, data: any): void;
+    clear(onlyData?: boolean): void;
+    #private;
+}
+export class LocalColorSpaceCache extends BaseLocalCache {
+    set(name: null | undefined, ref: null | undefined, data: any): void;
+}
+export class LocalFunctionCache extends BaseLocalCache {
+    set(name: null | undefined, ref: any, data: any): void;
+}
+export class LocalGStateCache extends BaseLocalCache {
+    set(name: any, ref: null | undefined, data: any): void;
+}
+export class LocalImageCache extends BaseLocalCache {
+    set(name: any, ref: null | undefined, data: any): void;
+}
+export class LocalTilingPatternCache extends BaseLocalCache {
+    set(name: null | undefined, ref: any, data: any): void;
+}
+export class RegionalImageCache extends BaseLocalCache {
+    set(name: null | undefined, ref: any, data: any): void;
+}
+declare class BaseLocalCache {
+    constructor(options: any);
+    _onlyRefs: boolean;
+    _nameRefMap: Map<any, any> | undefined;
+    _imageMap: Map<any, any> | undefined;
+    _imageCache: RefSetCache;
+    getByName(name: any): any;
+    getByRef(ref: any): any;
+    set(name: any, ref: any, data: any): void;
+}
+import { RefSetCache } from "./primitives.js";
+export {};

package/dist/types/src/core/jbig2_ccittFax.d.ts

@@ -0,0 +1,13 @@
+export class JBig2CCITTFaxImage extends WasmImage {
+    static get instance(): any;
+    _filename: string;
+    _noWasmFilename: string;
+    decode(bytes: any, width: any, height: any, globals: any, CCITTOptions: any): Promise<never>;
+}
+declare const Jbig2Error_base: any;
+export class Jbig2Error extends Jbig2Error_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+import { WasmImage } from "./wasm_image.js";
+export {};

package/dist/types/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 {
+    static stripFileHeader(bytes: any): any;
+    constructor(stream: any, maybeLength: any, params: any);
+    stream: any;
+    dict: any;
+    maybeLength: any;
+    params: any;
+    get bytes(): any;
+    ensureBuffer(requested: any): void;
+    decodeImage(bytes: any, length: any, _decoderOptions: any): Promise<Uint8Array<ArrayBuffer>>;
+    get canAsyncDecodeImageFromBuffer(): any;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/src/core/jpeg_stream.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 #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;
+    get jpegOptions(): any;
+    decodeImage(bytes: any): Uint8Array<ArrayBuffer>;
+    get canAsyncDecodeImageFromBuffer(): any;
+    getTransferableImage(): Promise<VideoFrame | null>;
+    #private;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/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;
+    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;
+    #private;
+}
+export {};

package/dist/types/src/core/jpx.d.ts

@@ -0,0 +1,24 @@
+declare const JpxError_base: any;
+export class JpxError extends JpxError_base {
+    [x: string]: any;
+    constructor(msg: any);
+}
+export class JpxImage extends WasmImage {
+    static get instance(): any;
+    static parseImageProperties(stream: any): {
+        width: number;
+        height: number;
+        bitsPerComponent: number;
+        componentsCount: any;
+    };
+    _filename: string;
+    _noWasmFilename: string;
+    decode(bytes: any, { numComponents, isIndexedColormap, smaskInData, reducePower, }?: {
+        numComponents?: number | undefined;
+        isIndexedColormap?: boolean | undefined;
+        smaskInData?: boolean | undefined;
+        reducePower?: number | undefined;
+    }): Promise<never>;
+}
+import { WasmImage } from "./wasm_image.js";
+export {};

package/dist/types/src/core/jpx_stream.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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);
+    stream: any;
+    dict: any;
+    maybeLength: any;
+    get bytes(): any;
+    ensureBuffer(requested: any): void;
+    decodeImage(bytes: any, _length: any, decoderOptions: any): Promise<Uint8Array<ArrayBuffer>>;
+    get canAsyncDecodeImageFromBuffer(): any;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/src/core/lzw_stream.d.ts

@@ -0,0 +1,19 @@
+export class LZWStream extends DecodeStream {
+    constructor(str: any, maybeLength: any, earlyChange: any);
+    stream: 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;
+}
+import { DecodeStream } from "./decode_stream.js";

package/dist/types/src/core/metadata_parser.d.ts

@@ -0,0 +1,13 @@
+export class MetadataParser {
+    constructor(data: any);
+    _metadataMap: Map<any, any>;
+    _data: any;
+    _repair(data: any): any;
+    _getSequence(entry: any): any;
+    _parseArray(entry: any): void;
+    _parse(xmlDocument: any): void;
+    get serializable(): {
+        parsedData: Map<any, any>;
+        rawData: any;
+    };
+}