unpdf 1.6.2 → 1.8.0

package/dist/types/external/brotli/decode.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @type {function(!Int8Array, ?Options=):!Int8Array}
+ */
+export let BrotliDecode: (arg0: Int8Array, arg1: (Options | null) | undefined) => Int8Array;
+export type Options = Object;

package/dist/types/external/jbig2/jbig2.d.ts

@@ -0,0 +1,2 @@
+export default JBig2;
+declare function JBig2(moduleArg?: {}): Promise<{}>;

package/dist/types/external/openjpeg/openjpeg.d.ts

@@ -0,0 +1,2 @@
+export default OpenJPEG;
+declare function OpenJPEG(moduleArg?: {}): Promise<{}>;

package/dist/types/external/qcms/qcms.d.ts

@@ -0,0 +1,92 @@
+/**
+ * # Safety
+ *
+ * This function is called directly from JavaScript.
+ * @param {number} transformer
+ * @param {Uint8Array} src
+ */
+export function qcms_convert_array(transformer: number, src: Uint8Array): void;
+/**
+ * # Safety
+ *
+ * This function is called directly from JavaScript.
+ * @param {number} transformer
+ * @param {number} src1
+ * @param {number} src2
+ * @param {number} src3
+ * @param {number} src4
+ * @param {boolean} css
+ */
+export function qcms_convert_four(transformer: number, src1: number, src2: number, src3: number, src4: number, css: boolean): void;
+/**
+ * # Safety
+ *
+ * This function is called directly from JavaScript.
+ * @param {number} transformer
+ * @param {number} src
+ * @param {boolean} css
+ */
+export function qcms_convert_one(transformer: number, src: number, css: boolean): void;
+/**
+ * # Safety
+ *
+ * This function is called directly from JavaScript.
+ * @param {number} transformer
+ * @param {number} src1
+ * @param {number} src2
+ * @param {number} src3
+ * @param {boolean} css
+ */
+export function qcms_convert_three(transformer: number, src1: number, src2: number, src3: number, css: boolean): void;
+/**
+ * # Safety
+ *
+ * This function is called directly from JavaScript.
+ * @param {number} transformer
+ */
+export function qcms_drop_transformer(transformer: number): void;
+/**
+ * # Safety
+ *
+ * This function is called directly from JavaScript.
+ * @param {Uint8Array} mem
+ * @param {DataType} in_type
+ * @param {Intent} intent
+ * @returns {number}
+ */
+export function qcms_transformer_from_memory(mem: Uint8Array, in_type: DataType, intent: Intent): number;
+export type DataType = 0 | 1 | 2 | 3 | 4 | 5;
+/**
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+export const DataType: Readonly<{
+    RGB8: 0;
+    "0": "RGB8";
+    RGBA8: 1;
+    "1": "RGBA8";
+    BGRA8: 2;
+    "2": "BGRA8";
+    Gray8: 3;
+    "3": "Gray8";
+    GrayA8: 4;
+    "4": "GrayA8";
+    CMYK: 5;
+    "5": "CMYK";
+}>;
+export type Intent = 0 | 1 | 2 | 3;
+/**
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const Intent: Readonly<{
+    Perceptual: 0;
+    "0": "Perceptual";
+    RelativeColorimetric: 1;
+    "1": "RelativeColorimetric";
+    Saturation: 2;
+    "2": "Saturation";
+    AbsoluteColorimetric: 3;
+    "3": "AbsoluteColorimetric";
+}>;
+export function initSync(module: any): any;
+declare function __wbg_init(module_or_path: any): Promise<any>;
+export { __wbg_init as default };

package/dist/types/external/qcms/qcms_utils.d.ts

@@ -0,0 +1,14 @@
+export function copy_result(ptr: any, len: any): void;
+export function copy_rgb(ptr: any): void;
+export function make_cssRGB(ptr: any): void;
+export class QCMS {
+    static #memoryArray: null;
+    static _memory: null;
+    static _mustAddAlpha: boolean;
+    static _destBuffer: null;
+    static _destOffset: number;
+    static _destLength: number;
+    static _cssColor: string;
+    static _makeHexColor: null;
+    static get _memoryArray(): Uint8Array<any>;
+}

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

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

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

@@ -0,0 +1,7 @@
+export class AsciiHexStream extends DecodeStream {
+    constructor(str: any, maybeLength: any);
+    stream: any;
+    dict: any;
+    firstDigit: number;
+}
+import { DecodeStream } from "./decode_stream.js";

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

@@ -0,0 +1,45 @@
+export class BaseStream {
+    /**
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * @returns {boolean}
+     */
+    get isEmpty(): boolean;
+    get isDataLoaded(): any;
+    getByte(): void;
+    /**
+     * @param {number | undefined} [length]
+     * @returns {Uint8Array}
+     */
+    getBytes(length?: number | undefined): Uint8Array;
+    /**
+     * NOTE: This method can only be used to get image-data that is guaranteed
+     *       to be fully loaded, since otherwise intermittent errors may occur;
+     *       note the `ObjectLoader` class.
+     */
+    getImageData(length: any, decoderOptions: any): Promise<Uint8Array<ArrayBufferLike>>;
+    asyncGetBytes(): Promise<void>;
+    get isAsync(): boolean;
+    get isAsyncDecoder(): boolean;
+    get isImageStream(): boolean;
+    get canAsyncDecodeImageFromBuffer(): boolean;
+    getTransferableImage(): Promise<null>;
+    peekByte(): void;
+    peekBytes(length: any): Uint8Array<ArrayBufferLike>;
+    getUint16(): any;
+    getInt32(): any;
+    getByteRange(begin: any, end: any): void;
+    getString(length: any): string;
+    skip(n: any): void;
+    reset(): void;
+    moveStart(): void;
+    makeSubStream(start: any, length: any, dict?: null): void;
+    clone(): void;
+    /**
+     * @returns {Array | null}
+     */
+    getBaseStreams(): any[] | null;
+    getOriginalStream(): any;
+}

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

@@ -0,0 +1,9 @@
+export class BrotliStream extends DecodeStream {
+    constructor(stream: any, maybeLength: any);
+    stream: any;
+    dict: any;
+    getImageData(length: any, _decoderOptions: any): Promise<Uint8Array<ArrayBuffer>>;
+    asyncGetBytes(): Promise<Uint8Array<ArrayBuffer> | null>;
+    #private;
+}
+import { DecodeStream } from "./decode_stream.js";

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

@@ -0,0 +1 @@
+export function calculateMD5(data: any, offset: any, length: any): Uint8Array<ArrayBuffer>;

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

@@ -0,0 +1 @@
+export function calculateSHA256(data: any, offset: any, length: any): Uint8Array<ArrayBuffer>;

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

@@ -0,0 +1,2 @@
+export function calculateSHA384(data: any, offset: any, length: any): Uint8Array<ArrayBuffer>;
+export function calculateSHA512(data: any, offset: any, length: any, mode384?: boolean): Uint8Array<ArrayBuffer>;

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

@@ -0,0 +1,169 @@
+/**
+ * Callback used to lazily fetch attachment content.
+ */
+export type GetAttachmentContent = (id: string) => CatalogAttachmentContent;
+/**
+ * Attachment value.
+ */
+export type CatalogAttachmentContent = Uint8Array | null;
+/**
+ * Attachment metadata.
+ */
+export type CatalogAttachment = {
+    /**
+     * Value, when already available.
+     */
+    content?: CatalogAttachmentContent | undefined;
+    /**
+     *   Description.
+     */
+    description: string;
+    /**
+     *   Filename (just the basename) for display.
+     */
+    filename: string;
+    /**
+     *   File path.
+     */
+    rawFilename: string;
+};
+export class Catalog {
+    /**
+     * @typedef {Object} ParseDestDictionaryParameters
+     * @property {Dict} destDict - The dictionary containing the destination.
+     * @property {Object} resultObj - The object where the parsed destination
+     *   properties will be placed.
+     * @property {string} [docBaseUrl] - The document base URL that is used when
+     *   attempting to recover valid absolute URLs from relative ones.
+     * @property {Record<string, CatalogAttachment> | null} [docAttachments] - The
+     *   document attachments (may not exist in most PDF documents).
+     */
+    /**
+     * Derive a destination array from a Structure Element reference.
+     * Walks the SE dict to find its page (Pg) and optional bounding box (A.BBox),
+     * then returns an XYZ destination array that can be used for navigation.
+     * @param {XRef} xref
+     * @param {Ref} seRef
+     * @returns {Array|null}
+     */
+    static #getDestFromStructElement(xref: XRef, seRef: Ref): any[] | null;
+    /**
+     * Helper function used to parse the contents of destination dictionaries.
+     * @param {ParseDestDictionaryParameters} params
+     */
+    static parseDestDictionary({ destDict, resultObj, docBaseUrl, docAttachments, }: {
+        /**
+         * - The dictionary containing the destination.
+         */
+        destDict: Dict;
+        /**
+         * - The object where the parsed destination
+         * properties will be placed.
+         */
+        resultObj: Object;
+        /**
+         * - The document base URL that is used when
+         * attempting to recover valid absolute URLs from relative ones.
+         */
+        docBaseUrl?: string | undefined;
+        /**
+         * - The
+         * document attachments (may not exist in most PDF documents).
+         */
+        docAttachments?: Record<string, CatalogAttachment> | null | undefined;
+    }): void;
+    constructor(pdfManager: any, xref: any);
+    builtInCMapCache: Map<any, any>;
+    fontCache: RefSetCache;
+    globalColorSpaceCache: GlobalColorSpaceCache;
+    globalImageCache: GlobalImageCache;
+    nonBlendModesSet: RefSet;
+    pageDictCache: RefSetCache;
+    pageIndexCache: RefSetCache;
+    pageKidsCountCache: RefSetCache;
+    standardFontDataCache: Map<any, any>;
+    systemFontCache: Map<any, any>;
+    pdfManager: any;
+    xref: any;
+    cloneDict(): any;
+    /**
+     * Create an id for an attachment from a FileAttachment annotation.
+     *
+     * The id is registered here rather than parsed from a public string prefix in
+     * `attachmentContent`, since catalog attachment names can be arbitrary PDF
+     * strings and may otherwise collide with annotation-local ids.
+     *
+     * @param {Ref} ref
+     *   File-spec or embedded-file stream reference.
+     * @returns {string}
+     *   Attachment id.
+     */
+    getAttachmentIdForAnnotation(ref: Ref): string;
+    get version(): any;
+    get lang(): any;
+    /**
+     * @type {boolean} `true` for pure XFA documents,
+     *   `false` for XFA Foreground documents.
+     */
+    get needsRendering(): boolean;
+    get collection(): any;
+    get acroForm(): any;
+    get acroFormRef(): any;
+    get metadata(): any;
+    get markInfo(): any;
+    get hasStructTree(): any;
+    get structTreeRoot(): any;
+    get toplevelPagesDict(): any;
+    get documentOutline(): any;
+    get documentOutlineForEditor(): any;
+    get permissions(): any;
+    get optionalContentConfig(): any;
+    setActualNumPages(num?: null): void;
+    get hasActualNumPages(): boolean;
+    get _pagesCount(): any;
+    get numPages(): any;
+    get destinations(): any;
+    getDestination(id: any): any;
+    get rawPageLabels(): Map<any, any> | null;
+    get pageLabels(): any;
+    get pageLayout(): any;
+    get pageMode(): any;
+    get viewerPreferences(): any;
+    get openAction(): any;
+    /**
+     * Get attachments.
+     *
+     * @returns {Map<string, CatalogAttachment> | null}
+     *   Attachments.
+     */
+    get attachments(): Map<string, CatalogAttachment> | null;
+    /**
+     * Get content for an attachment.
+     *
+     * @param {string} id
+     *   Unique attachment identifier (required).
+     * @returns {CatalogAttachmentContent}
+     *   Content.
+     */
+    attachmentContent(id: string): CatalogAttachmentContent;
+    get rawEmbeddedFiles(): Map<any, any> | null;
+    get xfaImages(): any;
+    get jsActions(): any;
+    cleanup(manuallyTriggered?: boolean): Promise<void>;
+    getPageDict(pageIndex: any): Promise<(Dict | Ref)[] | (Dict | null)[]>;
+    /**
+     * Eagerly fetches the entire /Pages-tree; should ONLY be used as a fallback.
+     * @returns {Promise<Map>}
+     */
+    getAllPageDicts(recoveryMode?: boolean): Promise<Map<any, any>>;
+    getPageIndex(pageRef: any): Promise<any>;
+    get baseUrl(): any;
+    #private;
+}
+import { RefSetCache } from "./primitives.js";
+import { GlobalColorSpaceCache } from "./image_utils.js";
+import { GlobalImageCache } from "./image_utils.js";
+import { RefSet } from "./primitives.js";
+import { Ref } from "./primitives.js";
+import { Dict } from "./primitives.js";
+import type { XRef } from "./xref.js";

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

@@ -0,0 +1,18 @@
+export class CCITTFaxStream extends DecodeStream {
+    constructor(str: any, maybeLength: any, params: any);
+    stream: any;
+    maybeLength: any;
+    dict: any;
+    params: {
+        K: any;
+        EndOfLine: boolean;
+        EncodedByteAlign: boolean;
+        Columns: any;
+        Rows: any;
+        EndOfBlock: boolean;
+        BlackIs1: boolean;
+    };
+    get bytes(): any;
+    decodeImage(bytes: any, length: any, _decoderOptions: any): Promise<Uint8Array<ArrayBuffer>>;
+}
+import { DecodeStream } from "./decode_stream.js";

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

@@ -0,0 +1 @@
+export function clearGlobalCaches(): void;

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

@@ -0,0 +1,177 @@
+/**
+ * Alternate color space handles both Separation and DeviceN color spaces.  A
+ * Separation color space is actually just a DeviceN with one color component.
+ * Both color spaces use a tinting function to convert colors to a base color
+ * space.
+ *
+ * The default color is `new Float32Array(new Array(numComps).fill(1))`.
+ */
+export class AlternateCS extends ColorSpace {
+    constructor(numComps: any, base: any, tintFn: any);
+    base: any;
+    tintFn: any;
+    tmpBuf: Float32Array<any>;
+    getOutputLength(inputLength: any, alpha01: any): any;
+}
+/**
+ * CalGrayCS: Based on "PDF Reference, Sixth Ed", p.245
+ *
+ * The default color is `new Float32Array([0])`.
+ */
+export class CalGrayCS extends ColorSpace {
+    constructor(whitePoint: any, blackPoint: any, gamma: any);
+    G: any;
+    XB: any;
+    YB: any;
+    ZB: any;
+    getOutputLength(inputLength: any, alpha01: any): number;
+    #private;
+}
+/**
+ * CalRGBCS: Based on "PDF Reference, Sixth Ed", p.247
+ *
+ * The default color is `new Float32Array([0, 0, 0])`.
+ */
+export class CalRGBCS extends ColorSpace {
+    static #BRADFORD_SCALE_MATRIX: Float32Array<ArrayBuffer>;
+    static #BRADFORD_SCALE_INVERSE_MATRIX: Float32Array<ArrayBuffer>;
+    static #SRGB_D65_XYZ_TO_RGB_MATRIX: Float32Array<ArrayBuffer>;
+    static #FLAT_WHITEPOINT_MATRIX: Float32Array<ArrayBuffer>;
+    static #tempNormalizeMatrix: Float32Array<ArrayBuffer>;
+    static #tempConvertMatrix1: Float32Array<ArrayBuffer>;
+    static #tempConvertMatrix2: Float32Array<ArrayBuffer>;
+    static #DECODE_L_CONSTANT: number;
+    constructor(whitePoint: any, blackPoint: any, gamma: any, matrix: any);
+    whitePoint: any;
+    blackPoint: any;
+    GR: any;
+    GG: any;
+    GB: any;
+    getOutputLength(inputLength: any, alpha01: any): number;
+    #private;
+}
+export class ColorSpace {
+    static #rgbBuf: Uint8ClampedArray<ArrayBuffer>;
+    /**
+     * Checks if a decode map matches the default decode map for a color space.
+     * This handles the general decode maps where there are two values per
+     * component, e.g. [0, 1, 0, 1, 0, 1] for a RGB color.
+     * This does not handle Lab, Indexed, or Pattern decode maps since they are
+     * slightly different.
+     * @param {Array} decode - Decode map (usually from an image).
+     * @param {number} numComps - Number of components the color space has.
+     */
+    static isDefaultDecode(decode: any[], numComps: number): boolean;
+    constructor(name: any, numComps: any);
+    name: any;
+    numComps: any;
+    /**
+     * Converts the color value to the RGB color. The color components are
+     * located in the src array starting from the srcOffset. Returns the array
+     * of the rgb components, each value ranging from [0,255].
+     */
+    getRgb(src: any, srcOffset: any, output?: Uint8ClampedArray<ArrayBuffer>): Uint8ClampedArray<ArrayBuffer>;
+    getRgbHex(src: any, srcOffset: any): string;
+    /**
+     * Converts the color value to the RGB color, similar to the getRgb method.
+     * The result placed into the dest array starting from the destOffset.
+     */
+    getRgbItem(src: any, srcOffset: any, dest: any, destOffset: any): void;
+    /**
+     * Converts the specified number of the color values to the RGB colors.
+     * The colors are located in the src array starting from the srcOffset.
+     * The result is placed into the dest array starting from the destOffset.
+     * The src array items shall be in [0,2^bits) range, the dest array items
+     * will be in [0,255] range. alpha01 indicates how many alpha components
+     * there are in the dest array; it will be either 0 (RGB array) or 1 (RGBA
+     * array).
+     */
+    getRgbBuffer(src: any, srcOffset: any, count: any, dest: any, destOffset: any, bits: any, alpha01: any): void;
+    /**
+     * Determines the number of bytes required to store the result of the
+     * conversion done by the getRgbBuffer method. As in getRgbBuffer,
+     * |alpha01| is either 0 (RGB output) or 1 (RGBA output).
+     */
+    getOutputLength(inputLength: any, alpha01: any): void;
+    /**
+     * Returns true if source data will be equal the result/output data.
+     */
+    isPassthrough(bits: any): boolean;
+    /**
+     * Refer to the static `ColorSpace.isDefaultDecode` method below.
+     */
+    isDefaultDecode(decode: any, bpc: any): boolean;
+    /**
+     * Fills in the RGB colors in the destination buffer.  alpha01 indicates
+     * how many alpha components there are in the dest array; it will be either
+     * 0 (RGB array) or 1 (RGBA array).
+     */
+    fillRgb(dest: any, originalWidth: any, originalHeight: any, width: any, height: any, actualHeight: any, bpc: any, comps: any, alpha01: any): void;
+    /**
+     * True if the colorspace has components in the default range of [0, 1].
+     * This should be true for all colorspaces except for lab color spaces
+     * which are [0,100], [-128, 127], [-128, 127].
+     */
+    get usesZeroToOneRange(): any;
+}
+/**
+ * The default color is `new Float32Array([0, 0, 0, 1])`.
+ */
+export class DeviceCmykCS extends ColorSpace {
+    constructor();
+    getOutputLength(inputLength: any, alpha01: any): number;
+    #private;
+}
+/**
+ * The default color is `new Float32Array([0])`.
+ */
+export class DeviceGrayCS extends ColorSpace {
+    constructor();
+    getOutputLength(inputLength: any, alpha01: any): number;
+}
+/**
+ * The default color is `new Float32Array([0, 0, 0, 1])`.
+ */
+export class DeviceRgbaCS extends ColorSpace {
+    constructor();
+    getOutputLength(inputLength: any, _alpha01: any): number;
+}
+/**
+ * The default color is `new Float32Array([0, 0, 0])`.
+ */
+export class DeviceRgbCS extends ColorSpace {
+    constructor();
+    getOutputLength(inputLength: any, alpha01: any): number;
+}
+/**
+ * The default color is `new Uint8Array([0])`.
+ */
+export class IndexedCS extends ColorSpace {
+    constructor(base: any, highVal: any, lookup: any);
+    base: any;
+    highVal: any;
+    lookup: Uint8Array<ArrayBuffer>;
+    getOutputLength(inputLength: any, alpha01: any): any;
+}
+/**
+ * LabCS: Based on "PDF Reference, Sixth Ed", p.250
+ *
+ * The default color is `new Float32Array([0, 0, 0])`.
+ */
+export class LabCS extends ColorSpace {
+    constructor(whitePoint: any, blackPoint: any, range: any);
+    XB: any;
+    YB: any;
+    ZB: any;
+    amin: any;
+    amax: any;
+    bmin: any;
+    bmax: any;
+    getOutputLength(inputLength: any, alpha01: any): number;
+    #private;
+}
+export class PatternCS extends ColorSpace {
+    constructor(baseCS: any);
+    base: any;
+    isDefaultDecode(decode: any, bpc: any): void;
+}

package/dist/types/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 #subParse(cs: any, options: any): any;
+    static #parse(cs: any, options: any): any;
+    static get gray(): any;
+    static get rgb(): any;
+    static get rgba(): any;
+    static get cmyk(): any;
+}