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

package/dist/pdf.js/external/openjpeg/openjpeg.d.ts

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

package/dist/pdf.js/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} 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
+ * @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 {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;
+/**
+ * # Safety
+ *
+ * This function is called directly from JavaScript.
+ * @param {number} transformer
+ */
+export function qcms_drop_transformer(transformer: number): void;
+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 default __wbg_init;
+export function initSync(module: any): any;
+declare function __wbg_init(module_or_path: any): Promise<any>;

package/dist/pdf.js/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 "__#private@#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/pdf.js/src/core/arithmetic_decoder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * This class implements the QM Coder decoding as defined in
+ *   JPEG 2000 Part I Final Committee Draft Version 1.0
+ *   Annex C.3 Arithmetic decoding procedure
+ * available at http://www.jpeg.org/public/fcd15444-1.pdf
+ *
+ * The arithmetic decoder is used in conjunction with context models to decode
+ * JPEG2000 and JBIG2 streams.
+ */
+export class ArithmeticDecoder {
+    constructor(data: any, start: any, end: any);
+    data: any;
+    bp: any;
+    dataEnd: any;
+    chigh: number;
+    clow: number;
+    a: number;
+    byteIn(): void;
+    ct: number | undefined;
+    readBit(contexts: any, pos: any): number;
+}

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

@@ -0,0 +1,8 @@
+export class Ascii85Stream extends DecodeStream {
+    constructor(str: any, maybeLength: any);
+    str: any;
+    dict: any;
+    input: Uint8Array<ArrayBuffer>;
+    readBlock(): void;
+}
+import { DecodeStream } from "./decode_stream.js";

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

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

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

@@ -0,0 +1,32 @@
+export class BaseStream {
+    get length(): void;
+    get isEmpty(): void;
+    get isDataLoaded(): any;
+    getByte(): void;
+    getBytes(length: any): void;
+    /**
+     * 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<void>;
+    asyncGetBytes(): Promise<void>;
+    get isAsync(): boolean;
+    get isAsyncDecoder(): boolean;
+    get canAsyncDecodeImageFromBuffer(): boolean;
+    getTransferableImage(): Promise<null>;
+    peekByte(): void;
+    peekBytes(length: any): void;
+    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;
+    /**
+     * @returns {Array | null}
+     */
+    getBaseStreams(): any[] | null;
+}

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

@@ -0,0 +1,3 @@
+export class BinaryCMapReader {
+    process(data: any, cMap: any, extend: any): Promise<any>;
+}

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

@@ -0,0 +1,72 @@
+export type CCITTFaxDecoderSource = {
+    /**
+     * - Method that return one byte of data for decoding,
+     * or -1 when EOF is reached.
+     */
+    next: Function;
+};
+/**
+ * @param {CCITTFaxDecoderSource} source - The data which should be decoded.
+ * @param {Object} [options] - Decoding options.
+ */
+export class CCITTFaxDecoder {
+    constructor(source: any, options?: {});
+    source: any;
+    eof: boolean;
+    encoding: any;
+    eoline: any;
+    byteAlign: any;
+    columns: any;
+    rows: any;
+    eoblock: any;
+    black: any;
+    codingLine: Uint32Array<any>;
+    refLine: Uint32Array<any>;
+    codingPos: number;
+    row: number;
+    nextLine2D: boolean;
+    inputBits: number;
+    inputBuf: number;
+    outputBits: number;
+    rowsDone: boolean;
+    readNextChar(): number;
+    err: boolean | undefined;
+    /**
+     * @private
+     */
+    private _addPixels;
+    /**
+     * @private
+     */
+    private _addPixelsNeg;
+    /**
+     * This function returns the code found from the table.
+     * The start and end parameters set the boundaries for searching the table.
+     * The limit parameter is optional. Function returns an array with three
+     * values. The first array element indicates whether a valid code is being
+     * returned. The second array element is the actual code. The third array
+     * element indicates whether EOF was reached.
+     * @private
+     */
+    private _findTableCode;
+    /**
+     * @private
+     */
+    private _getTwoDimCode;
+    /**
+     * @private
+     */
+    private _getWhiteCode;
+    /**
+     * @private
+     */
+    private _getBlackCode;
+    /**
+     * @private
+     */
+    private _lookBits;
+    /**
+     * @private
+     */
+    private _eatBits;
+}

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

@@ -0,0 +1,9 @@
+export class CCITTFaxStream extends DecodeStream {
+    constructor(str: any, maybeLength: any, params: any);
+    str: any;
+    dict: any;
+    ccittFaxDecoder: CCITTFaxDecoder;
+    readBlock(): void;
+}
+import { DecodeStream } from "./decode_stream.js";
+import { CCITTFaxDecoder } from "./ccitt.js";

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

@@ -0,0 +1,15 @@
+export class CFFFont {
+    constructor(file: any, properties: any);
+    properties: any;
+    cff: import("./cff_parser.js").CFF;
+    seacs: any;
+    data: any;
+    get numGlyphs(): any;
+    getCharset(): any;
+    getGlyphMapping(): any;
+    hasGlyphId(id: any): boolean;
+    /**
+     * @private
+     */
+    private _createBuiltInEncoding;
+}

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

@@ -0,0 +1,166 @@
+export class CFF {
+    header: any;
+    names: any[];
+    topDict: any;
+    strings: CFFStrings;
+    globalSubrIndex: any;
+    encoding: any;
+    charset: any;
+    charStrings: any;
+    fdArray: any[];
+    fdSelect: any;
+    isCIDFont: boolean;
+    duplicateFirstGlyph(): void;
+    hasGlyphId(id: any): boolean;
+}
+export class CFFCharset {
+    constructor(predefined: any, format: any, charset: any, raw: any);
+    predefined: any;
+    format: any;
+    charset: any;
+    raw: any;
+}
+export class CFFCompiler {
+    static get EncodeFloatRegExp(): any;
+    constructor(cff: any);
+    cff: any;
+    compile(): never[];
+    encodeNumber(value: any): any[];
+    encodeFloat(num: any): number[];
+    encodeInteger(value: any): any[];
+    compileHeader(header: any): any[];
+    compileNameIndex(names: any): number[];
+    compileTopDicts(dicts: any, length: any, removeCidKeys: any): {
+        trackers: CFFOffsetTracker[];
+        output: CFFIndex;
+    };
+    compilePrivateDicts(dicts: any, trackers: any, output: any): void;
+    compileDict(dict: any, offsetTracker: any): any[];
+    compileStringIndex(strings: any): number[];
+    compileCharStrings(charStrings: any): number[];
+    compileCharset(charset: any, numGlyphs: any, strings: any, isCIDFont: any): any[];
+    compileEncoding(encoding: any): any[];
+    compileFDSelect(fdSelect: any): any[];
+    compileTypedArray(data: any): any[];
+    compileIndex(index: any, trackers?: any[]): number[];
+}
+export class CFFFDSelect {
+    constructor(format: any, fdSelect: any);
+    format: any;
+    fdSelect: any;
+    getFDIndex(glyphIndex: any): any;
+}
+export class CFFHeader {
+    constructor(major: any, minor: any, hdrSize: any, offSize: any);
+    major: any;
+    minor: any;
+    hdrSize: any;
+    offSize: any;
+}
+export class CFFIndex {
+    objects: any[];
+    length: number;
+    add(data: any): void;
+    set(index: any, data: any): void;
+    get(index: any): any;
+    get count(): number;
+}
+export class CFFParser {
+    constructor(file: any, properties: any, seacAnalysisEnabled: any);
+    bytes: any;
+    properties: any;
+    seacAnalysisEnabled: boolean;
+    parse(): CFF;
+    cff: CFF | undefined;
+    parseHeader(): {
+        obj: CFFHeader;
+        endPos: any;
+    };
+    parseDict(dict: any): any[][];
+    parseIndex(pos: any): {
+        obj: CFFIndex;
+        endPos: any;
+    };
+    parseNameIndex(index: any): string[];
+    parseStringIndex(index: any): CFFStrings;
+    createDict(Type: any, dict: any, strings: any): any;
+    parseCharString(state: any, data: any, localSubrIndex: any, globalSubrIndex: any): boolean;
+    parseCharStrings({ charStrings, localSubrIndex, globalSubrIndex, fdSelect, fdArray, privateDict, }: {
+        charStrings: any;
+        localSubrIndex: any;
+        globalSubrIndex: any;
+        fdSelect: any;
+        fdArray: any;
+        privateDict: any;
+    }): {
+        charStrings: any;
+        seacs: any[];
+        widths: any[];
+    };
+    emptyPrivateDictionary(parentDict: any): void;
+    parsePrivateDict(parentDict: any): void;
+    parseCharsets(pos: any, length: any, strings: any, cid: any): CFFCharset;
+    parseEncoding(pos: any, properties: any, strings: any, charset: any): CFFEncoding;
+    parseFDSelect(pos: any, length: any): CFFFDSelect;
+}
+export class CFFPrivateDict extends CFFDict {
+    static get tables(): any;
+    constructor(strings: any);
+    subrsIndex: any;
+}
+/**
+ * The CFF class takes a Type1 file and wrap it into a
+ * 'Compact Font Format' which itself embed Type2 charstrings.
+ */
+export const CFFStandardStrings: string[];
+export class CFFStrings {
+    strings: any[];
+    get(index: any): any;
+    getSID(str: any): number;
+    add(value: any): void;
+    get count(): number;
+}
+export class CFFTopDict extends CFFDict {
+    static get tables(): any;
+    constructor(strings: any);
+    privateDict: any;
+}
+declare class CFFOffsetTracker {
+    offsets: any;
+    isTracking(key: any): boolean;
+    track(key: any, location: any): void;
+    offset(value: any): void;
+    setEntryLocation(key: any, values: any, output: any): void;
+}
+declare class CFFEncoding {
+    constructor(predefined: any, format: any, encoding: any, raw: any);
+    predefined: any;
+    format: any;
+    encoding: any;
+    raw: any;
+}
+declare class CFFDict {
+    static createTables(layout: any): {
+        keyToNameMap: {};
+        nameToKeyMap: {};
+        defaults: {};
+        types: {};
+        opcodes: {};
+        order: never[];
+    };
+    constructor(tables: any, strings: any);
+    keyToNameMap: any;
+    nameToKeyMap: any;
+    defaults: any;
+    types: any;
+    opcodes: any;
+    order: any;
+    strings: any;
+    values: any;
+    setByKey(key: any, value: any): boolean;
+    setByName(name: any, value: any): void;
+    hasName(name: any): boolean;
+    getByName(name: any): any;
+    removeByName(name: any): void;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export const ExpertCharset: string[];
+export const ExpertSubsetCharset: string[];
+export const ISOAdobeCharset: string[];

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

@@ -0,0 +1,37 @@
+export class CMap {
+    constructor(builtInCMap?: boolean);
+    codespaceRanges: never[][];
+    numCodespaceRanges: number;
+    _map: any[];
+    name: string;
+    vertical: boolean;
+    useCMap: any;
+    builtInCMap: boolean;
+    addCodespaceRange(n: any, low: any, high: any): void;
+    mapCidRange(low: any, high: any, dstLow: any): void;
+    mapBfRange(low: any, high: any, dstLow: any): void;
+    mapBfRangeToArray(low: any, high: any, array: any): void;
+    mapOne(src: any, dst: any): void;
+    lookup(code: any): any;
+    contains(code: any): boolean;
+    forEach(callback: any): void;
+    charCodeOf(value: any): number;
+    getMap(): any[];
+    readCharCode(str: any, offset: any, out: any): void;
+    getCharCodeLength(charCode: any): number;
+    get length(): number;
+    get isIdentityCMap(): boolean;
+}
+export class CMapFactory {
+    static create({ encoding, fetchBuiltInCMap, useCMap }: {
+        encoding: any;
+        fetchBuiltInCMap: any;
+        useCMap: any;
+    }): Promise<any>;
+}
+export class IdentityCMap extends CMap {
+    constructor(vertical: any, n: any);
+    vertical: any;
+    charCodeOf(value: any): any;
+    get isIdentityCMap(): void;
+}

package/dist/pdf.js/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 "__#private@#BRADFORD_SCALE_MATRIX": Float32Array<ArrayBuffer>;
+    static "__#private@#BRADFORD_SCALE_INVERSE_MATRIX": Float32Array<ArrayBuffer>;
+    static "__#private@#SRGB_D65_XYZ_TO_RGB_MATRIX": Float32Array<ArrayBuffer>;
+    static "__#private@#FLAT_WHITEPOINT_MATRIX": Float32Array<ArrayBuffer>;
+    static "__#private@#tempNormalizeMatrix": Float32Array<ArrayBuffer>;
+    static "__#private@#tempConvertMatrix1": Float32Array<ArrayBuffer>;
+    static "__#private@#tempConvertMatrix2": Float32Array<ArrayBuffer>;
+    static "__#private@#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 "__#private@#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(decodeMap: 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(decodeMap: any, bpc: any): void;
+}