@chialab/pdfjs-lib 1.0.0-alpha.26 → 1.0.0-alpha.28

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;
+}

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 {};