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

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,92 @@
+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(): 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 {};

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

@@ -0,0 +1,12 @@
+export class OpenTypeFileBuilder {
+    static getSearchParams(entriesCount: any, entrySize: any): {
+        range: number;
+        entry: number;
+        rangeShift: number;
+    };
+    constructor(sfnt: any);
+    sfnt: any;
+    tables: any;
+    toArray(): Uint8Array<ArrayBuffer>;
+    addTable(tag: any, data: any): void;
+}

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

@@ -0,0 +1,81 @@
+export class Lexer {
+    constructor(stream: any, knownCommands?: null);
+    stream: any;
+    strBuf: any[];
+    knownCommands: any;
+    _hexStringNumWarn: number;
+    beginInlineImagePos: number;
+    nextChar(): any;
+    currentChar: any;
+    peekChar(): any;
+    getNumber(): number;
+    getString(): string;
+    getName(): any;
+    /**
+     * @private
+     */
+    private _hexStringWarn;
+    getHexString(): string;
+    getObj(): any;
+    skipToNextLine(): void;
+}
+export class Linearization {
+    static create(stream: any): {
+        length: any;
+        hints: any[];
+        objectNumberFirst: any;
+        endFirst: any;
+        numPages: any;
+        mainXRefEntriesOffset: any;
+        pageFirst: any;
+    } | null;
+}
+export class Parser {
+    constructor({ lexer, xref, allowStreams, recoveryMode }: {
+        lexer: any;
+        xref: any;
+        allowStreams?: boolean | undefined;
+        recoveryMode?: boolean | undefined;
+    });
+    lexer: any;
+    xref: any;
+    allowStreams: boolean;
+    recoveryMode: boolean;
+    imageCache: any;
+    _imageId: number;
+    refill(): void;
+    buf1: any;
+    buf2: any;
+    shift(): void;
+    tryShift(): boolean;
+    getObj(cipherTransform?: null): any;
+    /**
+     * Find the end of the stream by searching for the /EI\s/.
+     * @returns {number} The inline stream length.
+     */
+    findDefaultInlineStreamEnd(stream: any): number;
+    /**
+     * Find the EOI (end-of-image) marker 0xFFD9 of the stream.
+     * @returns {number} The inline stream length.
+     */
+    findDCTDecodeInlineStreamEnd(stream: any): number;
+    /**
+     * Find the EOD (end-of-data) marker '~>' (i.e. TILDE + GT) of the stream.
+     * @returns {number} The inline stream length.
+     */
+    findASCII85DecodeInlineStreamEnd(stream: any): number;
+    /**
+     * Find the EOD (end-of-data) marker '>' (i.e. GT) of the stream.
+     * @returns {number} The inline stream length.
+     */
+    findASCIIHexDecodeInlineStreamEnd(stream: any): number;
+    /**
+     * Skip over the /EI/ for streams where we search for an EOD marker.
+     */
+    inlineStreamSkipEI(stream: any): void;
+    makeInlineImage(cipherTransform: any): any;
+    makeStream(dict: any, cipherTransform: any): any;
+    filter(stream: any, dict: any, length: any): any;
+    makeFilter(stream: any, name: any, maybeLength: any, params: any): any;
+    #private;
+}

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

@@ -0,0 +1,15 @@
+export class PredictorStream extends DecodeStream {
+    constructor(str: any, maybeLength: any, params: any);
+    predictor: any;
+    readBlock: (() => void) | undefined;
+    str: any;
+    dict: any;
+    colors: any;
+    bits: any;
+    columns: any;
+    pixBytes: number | undefined;
+    rowBytes: number | undefined;
+    readBlockTiff(): void;
+    readBlockPng(): void;
+}
+import { DecodeStream } from "./decode_stream.js";