Upload folder using huggingface_hub (part 46)

.gitattributes

@@ -107,3 +107,7 @@ tools/ui/node_modules/lightningcss-linux-x64-gnu/lightningcss.linux-x64-gnu.node
 tools/ui/node_modules/lightningcss-linux-x64-musl/lightningcss.linux-x64-musl.node filter=lfs diff=lfs merge=lfs -text
 tools/ui/node_modules/mermaid/dist/mermaid.js.map filter=lfs diff=lfs merge=lfs -text
 tools/ui/node_modules/mermaid/dist/mermaid.min.js.map filter=lfs diff=lfs merge=lfs -text
+tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-BoldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-Regular.ttf filter=lfs diff=lfs merge=lfs -text

tools/ui/node_modules/pdfjs-dist/standard_fonts/LICENSE_FOXIT

@@ -0,0 +1,27 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tools/ui/node_modules/pdfjs-dist/standard_fonts/LICENSE_LIBERATION

@@ -0,0 +1,102 @@
+Digitized data copyright (c) 2010 Google Corporation
+	with Reserved Font Arimo, Tinos and Cousine.
+Copyright (c) 2012 Red Hat, Inc.
+	with Reserved Font Name Liberation.
+
+This Font Software is licensed under the SIL Open Font License,
+Version 1.1.
+
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+
+PREAMBLE The goals of the Open Font License (OFL) are to stimulate
+worldwide development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to provide
+a free and open framework in which fonts may be shared and improved in
+partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves.
+The fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works.  The fonts and derivatives,
+however, cannot be released under any other type of license.  The
+requirement for fonts to remain under this license does not apply to
+any document created using the fonts or their derivatives.
+
+ 
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such.
+This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components
+as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting ? in part or in whole ?
+any of the components of the Original Version, by changing formats or
+by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer
+or other person who contributed to the Font Software.
+
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,in
+   Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+   redistributed and/or sold with any software, provided that each copy
+   contains the above copyright notice and this license. These can be
+   included either as stand-alone text files, human-readable headers or
+   in the appropriate machine-readable metadata fields within text or
+   binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+   Name(s) unless explicit written permission is granted by the
+   corresponding Copyright Holder. This restriction only applies to the
+   primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+   Software shall not be used to promote, endorse or advertise any
+   Modified Version, except to acknowledge the contribution(s) of the
+   Copyright Holder(s) and the Author(s) or with their explicit written
+   permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must
+   be distributed entirely under this license, and must not be distributed
+   under any other license. The requirement for fonts to remain under
+   this license does not apply to any document created using the Font
+   Software.
+
+
+ 
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+ 
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT.  IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
+DEALINGS IN THE FONT SOFTWARE.
+

tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-Bold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:361c61b82d575c5c35fd9157fda8b0194bcfcd0d88ea8521a4fb5dd53d33dddc
+size 137052

tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-BoldItalic.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a224075ac17495ad0a3af3bc0a419ac0704a8b3fd1095456201fb9b095fc281d
+size 135124

tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-Italic.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:832b4406dbef23628800d3aaad21048534ac84d7e3ad955be83b8172ed8ef512
+size 162036

tools/ui/node_modules/pdfjs-dist/standard_fonts/LiberationSans-Regular.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8ace1f892b2bd9dc1792ba7f097fa7588f84fed48321480e04de5390828221f
+size 139512

tools/ui/node_modules/pdfjs-dist/types/src/display/annotation_layer.d.ts

@@ -0,0 +1,244 @@
+export type PDFPageProxy = import("./api").PDFPageProxy;
+export type PageViewport = import("./display_utils").PageViewport;
+export type TextAccessibilityManager = import("../../web/text_accessibility.js").TextAccessibilityManager;
+export type IDownloadManager = import("../../web/interfaces").IDownloadManager;
+export type IPDFLinkService = import("../../web/interfaces").IPDFLinkService;
+export type AnnotationEditorUIManager = any;
+export type StructTreeLayerBuilder = import("../../web/struct_tree_layer_builder.js").StructTreeLayerBuilder;
+export type AnnotationElementParameters = {
+    data: Object;
+    layer: HTMLDivElement;
+    linkService: IPDFLinkService;
+    downloadManager?: import("../../web/interfaces").IDownloadManager | undefined;
+    annotationStorage?: AnnotationStorage | undefined;
+    /**
+     * - Path for image resources, mainly
+     * for annotation icons. Include trailing slash.
+     */
+    imageResourcesPath?: string | undefined;
+    renderForms: boolean;
+    svgFactory: Object;
+    enableScripting?: boolean | undefined;
+    hasJSActions?: boolean | undefined;
+    fieldObjects?: Object | undefined;
+};
+export type AnnotationLayerParameters = {
+    viewport: PageViewport;
+    div: HTMLDivElement;
+    annotations: any[];
+    page: PDFPageProxy;
+    linkService: IPDFLinkService;
+    downloadManager?: import("../../web/interfaces").IDownloadManager | undefined;
+    annotationStorage?: AnnotationStorage | undefined;
+    /**
+     * - Path for image resources, mainly
+     * for annotation icons. Include trailing slash.
+     */
+    imageResourcesPath?: string | undefined;
+    renderForms: boolean;
+    /**
+     * - Enable embedded script execution.
+     */
+    enableScripting?: boolean | undefined;
+    /**
+     * - Some fields have JS actions.
+     * The default value is `false`.
+     */
+    hasJSActions?: boolean | undefined;
+    fieldObjects?: {
+        [x: string]: Object[];
+    } | null | undefined;
+    annotationCanvasMap?: Map<string, HTMLCanvasElement> | undefined;
+    accessibilityManager?: import("../../web/text_accessibility.js").TextAccessibilityManager | undefined;
+    annotationEditorUIManager?: AnnotationEditorUIManager;
+    structTreeLayer?: import("../../web/struct_tree_layer_builder.js").StructTreeLayerBuilder | undefined;
+};
+/**
+ * @typedef {Object} AnnotationLayerParameters
+ * @property {PageViewport} viewport
+ * @property {HTMLDivElement} div
+ * @property {Array} annotations
+ * @property {PDFPageProxy} page
+ * @property {IPDFLinkService} linkService
+ * @property {IDownloadManager} [downloadManager]
+ * @property {AnnotationStorage} [annotationStorage]
+ * @property {string} [imageResourcesPath] - Path for image resources, mainly
+ *   for annotation icons. Include trailing slash.
+ * @property {boolean} renderForms
+ * @property {boolean} [enableScripting] - Enable embedded script execution.
+ * @property {boolean} [hasJSActions] - Some fields have JS actions.
+ *   The default value is `false`.
+ * @property {Object<string, Array<Object>> | null} [fieldObjects]
+ * @property {Map<string, HTMLCanvasElement>} [annotationCanvasMap]
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ * @property {AnnotationEditorUIManager} [annotationEditorUIManager]
+ * @property {StructTreeLayerBuilder} [structTreeLayer]
+ */
+/**
+ * Manage the layer containing all the annotations.
+ */
+export class AnnotationLayer {
+    /**
+     * @private
+     */
+    private static get _defaultBorderStyle();
+    constructor({ div, accessibilityManager, annotationCanvasMap, annotationEditorUIManager, page, viewport, structTreeLayer, }: {
+        div: any;
+        accessibilityManager: any;
+        annotationCanvasMap: any;
+        annotationEditorUIManager: any;
+        page: any;
+        viewport: any;
+        structTreeLayer: any;
+    });
+    div: any;
+    page: any;
+    viewport: any;
+    zIndex: number;
+    _annotationEditorUIManager: any;
+    popupShow: any[] | undefined;
+    hasEditableAnnotations(): boolean;
+    /**
+     * Render a new annotation layer with all annotation elements.
+     *
+     * @param {AnnotationLayerParameters} params
+     * @memberof AnnotationLayer
+     */
+    render(params: AnnotationLayerParameters): Promise<void>;
+    /**
+     * Add link annotations to the annotation layer.
+     *
+     * @param {Array<Object>} annotations
+     * @param {IPDFLinkService} linkService
+     * @memberof AnnotationLayer
+     */
+    addLinkAnnotations(annotations: Array<Object>, linkService: IPDFLinkService): Promise<void>;
+    /**
+     * Update the annotation elements on existing annotation layer.
+     *
+     * @param {AnnotationLayerParameters} viewport
+     * @memberof AnnotationLayer
+     */
+    update({ viewport }: AnnotationLayerParameters): void;
+    getEditableAnnotations(): any[];
+    getEditableAnnotation(id: any): any;
+    #private;
+}
+export class FreeTextAnnotationElement extends AnnotationElement {
+    constructor(parameters: any);
+    textContent: any;
+    textPosition: any;
+    annotationEditorType: number;
+    render(): HTMLElement | undefined;
+}
+export class HighlightAnnotationElement extends AnnotationElement {
+    constructor(parameters: any);
+    annotationEditorType: number;
+    render(): HTMLElement | undefined;
+}
+export class InkAnnotationElement extends AnnotationElement {
+    constructor(parameters: any);
+    containerClassName: string;
+    svgElementName: string;
+    annotationEditorType: number;
+    render(): HTMLElement | undefined;
+    getElementsToTriggerPopup(): any[];
+    #private;
+}
+export class StampAnnotationElement extends AnnotationElement {
+    constructor(parameters: any);
+    annotationEditorType: number;
+    render(): HTMLElement | undefined;
+}
+import { AnnotationStorage } from "./annotation_storage.js";
+declare class AnnotationElement {
+    static _hasPopupData({ contentsObj, richText }: {
+        contentsObj: any;
+        richText: any;
+    }): boolean;
+    constructor(parameters: any, { isRenderable, ignoreBorder, createQuadrilaterals, }?: {
+        isRenderable?: boolean | undefined;
+        ignoreBorder?: boolean | undefined;
+        createQuadrilaterals?: boolean | undefined;
+    });
+    isRenderable: boolean;
+    data: any;
+    layer: any;
+    linkService: any;
+    downloadManager: any;
+    imageResourcesPath: any;
+    renderForms: any;
+    svgFactory: any;
+    annotationStorage: any;
+    enableScripting: any;
+    hasJSActions: any;
+    _fieldObjects: any;
+    parent: any;
+    container: HTMLElement | undefined;
+    get _isEditable(): any;
+    get hasPopupData(): boolean;
+    updateEdited(params: any): void;
+    popup: any;
+    resetEdited(): void;
+    /**
+     * Create an empty container for the annotation's HTML element.
+     *
+     * @private
+     * @param {boolean} ignoreBorder
+     * @memberof AnnotationElement
+     * @returns {HTMLElement} A section element.
+     */
+    private _createContainer;
+    setRotation(angle: any, container?: HTMLElement | undefined): void;
+    get _commonActions(): any;
+    _dispatchEventFromSandbox(actions: any, jsEvent: any): void;
+    _setDefaultPropertiesFromJS(element: any): void;
+    /**
+     * Create quadrilaterals from the annotation's quadpoints.
+     *
+     * @private
+     * @memberof AnnotationElement
+     */
+    private _createQuadrilaterals;
+    /**
+     * Create a popup for the annotation's HTML element. This is used for
+     * annotations that do not have a Popup entry in the dictionary, but
+     * are of a type that works with popups (such as Highlight annotations).
+     *
+     * @param {Object} [popupData] - The data for the popup, if any.
+     *
+     * @private
+     * @memberof AnnotationElement
+     */
+    private _createPopup;
+    get hasPopupElement(): boolean;
+    /**
+     * Render the annotation's HTML element(s).
+     *
+     * @public
+     * @memberof AnnotationElement
+     */
+    public render(): void;
+    /**
+     * @private
+     * @returns {Array}
+     */
+    private _getElementsByName;
+    show(): void;
+    hide(): void;
+    /**
+     * Get the HTML element(s) which can trigger a popup when clicked or hovered.
+     *
+     * @public
+     * @memberof AnnotationElement
+     * @returns {Array<HTMLElement>|HTMLElement} An array of elements or an
+     *          element.
+     */
+    public getElementsToTriggerPopup(): Array<HTMLElement> | HTMLElement;
+    addHighlightArea(): void;
+    _editOnDoubleClick(): void;
+    get width(): number;
+    get height(): number;
+    #private;
+}
+export {};

tools/ui/node_modules/pdfjs-dist/types/src/display/annotation_storage.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Key/value storage for annotation data in forms.
+ */
+export class AnnotationStorage {
+    onSetModified: any;
+    onResetModified: any;
+    onAnnotationEditor: any;
+    /**
+     * Get the value for a given key if it exists, or return the default value.
+     * @param {string} key
+     * @param {Object} defaultValue
+     * @returns {Object}
+     */
+    getValue(key: string, defaultValue: Object): Object;
+    /**
+     * Get the value for a given key.
+     * @param {string} key
+     * @returns {Object}
+     */
+    getRawValue(key: string): Object;
+    /**
+     * Remove a value from the storage.
+     * @param {string} key
+     */
+    remove(key: string): void;
+    /**
+     * Set the value for a given key
+     * @param {string} key
+     * @param {Object} value
+     */
+    setValue(key: string, value: Object): void;
+    /**
+     * Check if the storage contains the given key.
+     * @param {string} key
+     * @returns {boolean}
+     */
+    has(key: string): boolean;
+    get size(): number;
+    resetModified(): void;
+    /**
+     * @returns {PrintAnnotationStorage}
+     */
+    get print(): PrintAnnotationStorage;
+    /**
+     * PLEASE NOTE: Only intended for usage within the API itself.
+     * @ignore
+     */
+    get serializable(): Readonly<{
+        map: null;
+        hash: "";
+        transfer: undefined;
+    }> | {
+        map: Map<any, any>;
+        hash: string;
+        transfer: any[];
+    };
+    get editorStats(): any;
+    resetModifiedIds(): void;
+    /**
+     * @returns {{ids: Set<string>, hash: string}}
+     */
+    get modifiedIds(): {
+        ids: Set<string>;
+        hash: string;
+    };
+    [Symbol.iterator](): MapIterator<[any, any]>;
+    #private;
+}
+/**
+ * A special `AnnotationStorage` for use during printing, where the serializable
+ * data is *frozen* upon initialization, to prevent scripting from modifying its
+ * contents. (Necessary since printing is triggered synchronously in browsers.)
+ */
+export class PrintAnnotationStorage extends AnnotationStorage {
+    constructor(parent: any);
+    /**
+     * PLEASE NOTE: Only intended for usage within the API itself.
+     * @ignore
+     */
+    get serializable(): {
+        map: any;
+        hash: any;
+        transfer: any;
+    };
+    get modifiedIds(): any;
+    #private;
+}
+export const SerializableEmpty: Readonly<{
+    map: null;
+    hash: "";
+    transfer: undefined;
+}>;

tools/ui/node_modules/pdfjs-dist/types/src/display/api.d.ts

@@ -0,0 +1,1567 @@
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export type RefProxy = {
+    num: number;
+    gen: number;
+};
+/**
+ * Document initialization / loading parameters object.
+ */
+export type DocumentInitParameters = {
+    /**
+     * - The URL of the PDF.
+     */
+    url?: string | URL | undefined;
+    /**
+     * -
+     * Binary PDF data.
+     * Use TypedArrays (Uint8Array) to improve the memory usage. If PDF data is
+     * BASE64-encoded, use `atob()` to convert it to a binary string first.
+     *
+     * NOTE: If TypedArrays are used they will generally be transferred to the
+     * worker-thread. This will help reduce main-thread memory usage, however
+     * it will take ownership of the TypedArrays.
+     */
+    data?: string | number[] | ArrayBuffer | TypedArray | undefined;
+    /**
+     * - Basic authentication headers.
+     */
+    httpHeaders?: Object | undefined;
+    /**
+     * - Indicates whether or not
+     * cross-site Access-Control requests should be made using credentials such
+     * as cookies or authorization headers. The default is `false`.
+     */
+    withCredentials?: boolean | undefined;
+    /**
+     * - For decrypting password-protected PDFs.
+     */
+    password?: string | undefined;
+    /**
+     * - The PDF file length. It's used for progress
+     * reports and range requests operations.
+     */
+    length?: number | undefined;
+    /**
+     * - Allows for using a custom range
+     * transport implementation.
+     */
+    range?: PDFDataRangeTransport | undefined;
+    /**
+     * - Specify maximum number of bytes fetched
+     * per range request. The default value is 65536 (= 2^16).
+     */
+    rangeChunkSize?: number | undefined;
+    /**
+     * - The worker that will be used for loading and
+     * parsing the PDF data.
+     */
+    worker?: PDFWorker | undefined;
+    /**
+     * - Controls the logging level; the constants
+     * from {@link VerbosityLevel} should be used.
+     */
+    verbosity?: number | undefined;
+    /**
+     * - The base URL of the document, used when
+     * attempting to recover valid absolute URLs for annotations, and outline
+     * items, that (incorrectly) only specify relative URLs.
+     */
+    docBaseUrl?: string | undefined;
+    /**
+     * - The URL where the predefined Adobe CMaps are
+     * located. Include the trailing slash.
+     */
+    cMapUrl?: string | undefined;
+    /**
+     * - Specifies if the Adobe CMaps are binary
+     * packed or not. The default value is `true`.
+     */
+    cMapPacked?: boolean | undefined;
+    /**
+     * - The factory that will be used when
+     * reading built-in CMap files.
+     * The default value is {DOMCMapReaderFactory}.
+     */
+    CMapReaderFactory?: Object | undefined;
+    /**
+     * - The URL where the predefined ICC profiles are
+     * located. Include the trailing slash.
+     */
+    iccUrl?: string | undefined;
+    /**
+     * - When `true`, fonts that aren't
+     * embedded in the PDF document will fallback to a system font.
+     * The default value is `true` in web environments and `false` in Node.js;
+     * unless `disableFontFace === true` in which case this defaults to `false`
+     * regardless of the environment (to prevent completely broken fonts).
+     */
+    useSystemFonts?: boolean | undefined;
+    /**
+     * - The URL where the standard font
+     * files are located. Include the trailing slash.
+     */
+    standardFontDataUrl?: string | undefined;
+    /**
+     * - The factory that will be used
+     * when reading the standard font files.
+     * The default value is {DOMStandardFontDataFactory}.
+     */
+    StandardFontDataFactory?: Object | undefined;
+    /**
+     * - The URL where the wasm files are located.
+     * Include the trailing slash.
+     */
+    wasmUrl?: string | undefined;
+    /**
+     * - The factory that will be used
+     * when reading the wasm files.
+     * The default value is {DOMWasmFactory}.
+     */
+    WasmFactory?: Object | undefined;
+    /**
+     * - Enable using the Fetch API in the
+     * worker-thread when reading CMap and standard font files. When `true`,
+     * the `CMapReaderFactory`, `StandardFontDataFactory`, and `WasmFactory`
+     * options are ignored.
+     * The default value is `true` in web environments and `false` in Node.js.
+     */
+    useWorkerFetch?: boolean | undefined;
+    /**
+     * - Attempt to use WebAssembly in order to
+     * improve e.g. image decoding performance.
+     * The default value is `true`.
+     */
+    useWasm?: boolean | undefined;
+    /**
+     * - Reject certain promises, e.g.
+     * `getOperatorList`, `getTextContent`, and `RenderTask`, when the associated
+     * PDF data cannot be successfully parsed, instead of attempting to recover
+     * whatever possible of the data. The default value is `false`.
+     */
+    stopAtErrors?: boolean | undefined;
+    /**
+     * - The maximum allowed image size in total
+     * pixels, i.e. width * height. Images above this value will not be rendered.
+     * Use -1 for no limit, which is also the default value.
+     */
+    maxImageSize?: number | undefined;
+    /**
+     * - Determines if we can evaluate strings
+     * as JavaScript. Primarily used to improve performance of PDF functions.
+     * The default value is `true`.
+     */
+    isEvalSupported?: boolean | undefined;
+    /**
+     * - Determines if we can use
+     * `OffscreenCanvas` in the worker. Primarily used to improve performance of
+     * image conversion/rendering.
+     * The default value is `true` in web environments and `false` in Node.js.
+     */
+    isOffscreenCanvasSupported?: boolean | undefined;
+    /**
+     * - Determines if we can use
+     * `ImageDecoder` in the worker. Primarily used to improve performance of
+     * image conversion/rendering.
+     * The default value is `true` in web environments and `false` in Node.js.
+     *
+     * NOTE: Also temporarily disabled in Chromium browsers, until we no longer
+     * support the affected browser versions, because of various bugs:
+     *
+     * - Crashes when using the BMP decoder with huge images, e.g. issue6741.pdf;
+     * see https://issues.chromium.org/issues/374807001
+     *
+     * - Broken images when using the JPEG decoder with images that have custom
+     * colour profiles, e.g. GitHub discussion 19030;
+     * see https://issues.chromium.org/issues/378869810
+     */
+    isImageDecoderSupported?: boolean | undefined;
+    /**
+     * - The integer value is used to
+     * know when an image must be resized (uses `OffscreenCanvas` in the worker).
+     * If it's -1 then a possibly slow algorithm is used to guess the max value.
+     */
+    canvasMaxAreaInBytes?: number | undefined;
+    /**
+     * - By default fonts are converted to
+     * OpenType fonts and loaded via the Font Loading API or `@font-face` rules.
+     * If disabled, fonts will be rendered using a built-in font renderer that
+     * constructs the glyphs with primitive path commands.
+     * The default value is `false` in web environments and `true` in Node.js.
+     */
+    disableFontFace?: boolean | undefined;
+    /**
+     * - Include additional properties,
+     * which are unused during rendering of PDF documents, when exporting the
+     * parsed font data from the worker-thread. This may be useful for debugging
+     * purposes (and backwards compatibility), but note that it will lead to
+     * increased memory usage. The default value is `false`.
+     */
+    fontExtraProperties?: boolean | undefined;
+    /**
+     * - Render Xfa forms if any.
+     * The default value is `false`.
+     */
+    enableXfa?: boolean | undefined;
+    /**
+     * - Specify an explicit document
+     * context to create elements with and to load resources, such as fonts,
+     * into. Defaults to the current document.
+     */
+    ownerDocument?: HTMLDocument | undefined;
+    /**
+     * - Disable range request loading of PDF
+     * files. When enabled, and if the server supports partial content requests,
+     * then the PDF will be fetched in chunks. The default value is `false`.
+     */
+    disableRange?: boolean | undefined;
+    /**
+     * - Disable streaming of PDF file data.
+     * By default PDF.js attempts to load PDF files in chunks. The default value
+     * is `false`.
+     */
+    disableStream?: boolean | undefined;
+    /**
+     * - Disable pre-fetching of PDF file
+     * data. When range requests are enabled PDF.js will automatically keep
+     * fetching more data even if it isn't needed to display the current page.
+     * The default value is `false`.
+     *
+     * NOTE: It is also necessary to disable streaming, see above, in order for
+     * disabling of pre-fetching to work correctly.
+     */
+    disableAutoFetch?: boolean | undefined;
+    /**
+     * - Enables special hooks for debugging PDF.js
+     * (see `web/debugger.js`). The default value is `false`.
+     */
+    pdfBug?: boolean | undefined;
+    /**
+     * - The factory that will be used when
+     * creating canvases. The default value is {DOMCanvasFactory}.
+     */
+    CanvasFactory?: Object | undefined;
+    /**
+     * - The factory that will be used to
+     * create SVG filters when rendering some images on the main canvas.
+     * The default value is {DOMFilterFactory}.
+     */
+    FilterFactory?: Object | undefined;
+    /**
+     * - Enables hardware acceleration for
+     * rendering. The default value is `false`.
+     */
+    enableHWA?: boolean | undefined;
+};
+export type OnProgressParameters = {
+    /**
+     * - Currently loaded number of bytes.
+     */
+    loaded: number;
+    /**
+     * - Total number of bytes in the PDF file.
+     */
+    total: number;
+};
+/**
+ * Page getViewport parameters.
+ */
+export type GetViewportParameters = {
+    /**
+     * - The desired scale of the viewport.
+     */
+    scale: number;
+    /**
+     * - The desired rotation, in degrees, of
+     * the viewport. If omitted it defaults to the page rotation.
+     */
+    rotation?: number | undefined;
+    /**
+     * - The horizontal, i.e. x-axis, offset.
+     * The default value is `0`.
+     */
+    offsetX?: number | undefined;
+    /**
+     * - The vertical, i.e. y-axis, offset.
+     * The default value is `0`.
+     */
+    offsetY?: number | undefined;
+    /**
+     * - If true, the y-axis will not be
+     * flipped. The default value is `false`.
+     */
+    dontFlip?: boolean | undefined;
+};
+/**
+ * Page getTextContent parameters.
+ */
+export type getTextContentParameters = {
+    /**
+     * - When true include marked
+     * content items in the items array of TextContent. The default is `false`.
+     */
+    includeMarkedContent?: boolean | undefined;
+    /**
+     * - When true the text is *not*
+     * normalized in the worker-thread. The default is `false`.
+     */
+    disableNormalization?: boolean | undefined;
+};
+/**
+ * Page text content.
+ */
+export type TextContent = {
+    /**
+     * - Array of
+     * {@link TextItem} and {@link TextMarkedContent} objects. TextMarkedContent
+     * items are included when includeMarkedContent is true.
+     */
+    items: Array<TextItem | TextMarkedContent>;
+    /**
+     * - {@link TextStyle} objects,
+     * indexed by font name.
+     */
+    styles: {
+        [x: string]: TextStyle;
+    };
+    /**
+     * - The document /Lang attribute.
+     */
+    lang: string | null;
+};
+/**
+ * Page text content part.
+ */
+export type TextItem = {
+    /**
+     * - Text content.
+     */
+    str: string;
+    /**
+     * - Text direction: 'ttb', 'ltr' or 'rtl'.
+     */
+    dir: string;
+    /**
+     * - Transformation matrix.
+     */
+    transform: Array<any>;
+    /**
+     * - Width in device space.
+     */
+    width: number;
+    /**
+     * - Height in device space.
+     */
+    height: number;
+    /**
+     * - Font name used by PDF.js for converted font.
+     */
+    fontName: string;
+    /**
+     * - Indicating if the text content is followed by a
+     * line-break.
+     */
+    hasEOL: boolean;
+};
+/**
+ * Page text marked content part.
+ */
+export type TextMarkedContent = {
+    /**
+     * - Either 'beginMarkedContent',
+     * 'beginMarkedContentProps', or 'endMarkedContent'.
+     */
+    type: string;
+    /**
+     * - The marked content identifier. Only used for type
+     * 'beginMarkedContentProps'.
+     */
+    id: string;
+};
+/**
+ * Text style.
+ */
+export type TextStyle = {
+    /**
+     * - Font ascent.
+     */
+    ascent: number;
+    /**
+     * - Font descent.
+     */
+    descent: number;
+    /**
+     * - Whether or not the text is in vertical mode.
+     */
+    vertical: boolean;
+    /**
+     * - The possible font family.
+     */
+    fontFamily: string;
+};
+/**
+ * Page annotation parameters.
+ */
+export type GetAnnotationsParameters = {
+    /**
+     * - Determines the annotations that are fetched,
+     * can be 'display' (viewable annotations), 'print' (printable annotations),
+     * or 'any' (all annotations). The default value is 'display'.
+     */
+    intent?: string | undefined;
+};
+/**
+ * Page render parameters.
+ */
+export type RenderParameters = {
+    /**
+     * - 2D context of a DOM
+     * Canvas object for backwards compatibility; it is recommended to use the
+     * `canvas` parameter instead.
+     * If the context must absolutely be used to render the page, the canvas must
+     * be null.
+     */
+    canvasContext: CanvasRenderingContext2D;
+    /**
+     * - A DOM Canvas object. The default
+     * value is the canvas associated with the `canvasContext` parameter if no
+     * value is provided explicitly.
+     */
+    canvas: HTMLCanvasElement | null;
+    /**
+     * - Rendering viewport obtained by calling
+     * the `PDFPageProxy.getViewport` method.
+     */
+    viewport: PageViewport;
+    /**
+     * - Rendering intent, can be 'display', 'print',
+     * or 'any'. The default value is 'display'.
+     */
+    intent?: string | undefined;
+    /**
+     * Controls which annotations are rendered
+     * onto the canvas, for annotations with appearance-data; the values from
+     * {@link AnnotationMode} should be used. The following values are supported:
+     * - `AnnotationMode.DISABLE`, which disables all annotations.
+     * - `AnnotationMode.ENABLE`, which includes all possible annotations (thus
+     * it also depends on the `intent`-option, see above).
+     * - `AnnotationMode.ENABLE_FORMS`, which excludes annotations that contain
+     * interactive form elements (those will be rendered in the display layer).
+     * - `AnnotationMode.ENABLE_STORAGE`, which includes all possible annotations
+     * (as above) but where interactive form elements are updated with data
+     * from the {@link AnnotationStorage}-instance; useful e.g. for printing.
+     * The default value is `AnnotationMode.ENABLE`.
+     */
+    annotationMode?: number | undefined;
+    /**
+     * - Additional transform, applied just
+     * before viewport transform.
+     */
+    transform?: any[] | undefined;
+    /**
+     * - Background
+     * to use for the canvas.
+     * Any valid `canvas.fillStyle` can be used: a `DOMString` parsed as CSS
+     * <color> value, a `CanvasGradient` object (a linear or radial gradient) or
+     * a `CanvasPattern` object (a repetitive image). The default value is
+     * 'rgb(255,255,255)'.
+     *
+     * NOTE: This option may be partially, or completely, ignored when the
+     * `pageColors`-option is used.
+     */
+    background?: string | CanvasGradient | CanvasPattern | undefined;
+    /**
+     * - Overwrites background and foreground colors
+     * with user defined ones in order to improve readability in high contrast
+     * mode.
+     */
+    pageColors?: Object | undefined;
+    /**
+     * -
+     * A promise that should resolve with an {@link OptionalContentConfig}created from `PDFDocumentProxy.getOptionalContentConfig`. If `null`,
+     * the configuration will be fetched automatically with the default visibility
+     * states set.
+     */
+    optionalContentConfigPromise?: Promise<OptionalContentConfig> | undefined;
+    /**
+     * - Map some
+     * annotation ids with canvases used to render them.
+     */
+    annotationCanvasMap?: Map<string, HTMLCanvasElement> | undefined;
+    printAnnotationStorage?: PrintAnnotationStorage | undefined;
+    /**
+     * - Render the page in editing mode.
+     */
+    isEditing?: boolean | undefined;
+};
+/**
+ * Page getOperatorList parameters.
+ */
+export type GetOperatorListParameters = {
+    /**
+     * - Rendering intent, can be 'display', 'print',
+     * or 'any'. The default value is 'display'.
+     */
+    intent?: string | undefined;
+    /**
+     * Controls which annotations are included
+     * in the operatorList, for annotations with appearance-data; the values from
+     * {@link AnnotationMode} should be used. The following values are supported:
+     * - `AnnotationMode.DISABLE`, which disables all annotations.
+     * - `AnnotationMode.ENABLE`, which includes all possible annotations (thus
+     * it also depends on the `intent`-option, see above).
+     * - `AnnotationMode.ENABLE_FORMS`, which excludes annotations that contain
+     * interactive form elements (those will be rendered in the display layer).
+     * - `AnnotationMode.ENABLE_STORAGE`, which includes all possible annotations
+     * (as above) but where interactive form elements are updated with data
+     * from the {@link AnnotationStorage}-instance; useful e.g. for printing.
+     * The default value is `AnnotationMode.ENABLE`.
+     */
+    annotationMode?: number | undefined;
+    printAnnotationStorage?: PrintAnnotationStorage | undefined;
+    /**
+     * - Render the page in editing mode.
+     */
+    isEditing?: boolean | undefined;
+};
+/**
+ * Structure tree node. The root node will have a role "Root".
+ */
+export type StructTreeNode = {
+    /**
+     * - Array of
+     * {@link StructTreeNode} and {@link StructTreeContent} objects.
+     */
+    children: Array<StructTreeNode | StructTreeContent>;
+    /**
+     * - element's role, already mapped if a role map exists
+     * in the PDF.
+     */
+    role: string;
+};
+/**
+ * Structure tree content.
+ */
+export type StructTreeContent = {
+    /**
+     * - either "content" for page and stream structure
+     * elements or "object" for object references.
+     */
+    type: string;
+    /**
+     * - unique id that will map to the text layer.
+     */
+    id: string;
+};
+/**
+ * PDF page operator list.
+ */
+export type PDFOperatorList = {
+    /**
+     * - Array containing the operator functions.
+     */
+    fnArray: Array<number>;
+    /**
+     * - Array containing the arguments of the
+     * functions.
+     */
+    argsArray: Array<any>;
+};
+export type PDFWorkerParameters = {
+    /**
+     * - The name of the worker.
+     */
+    name?: string | undefined;
+    /**
+     * - The `workerPort` object.
+     */
+    port?: Worker | undefined;
+    /**
+     * - Controls the logging level;
+     * the constants from {@link VerbosityLevel} should be used.
+     */
+    verbosity?: number | undefined;
+};
+/** @type {string} */
+export const build: string;
+/**
+ * @typedef { Int8Array | Uint8Array | Uint8ClampedArray |
+ *            Int16Array | Uint16Array |
+ *            Int32Array | Uint32Array | Float32Array |
+ *            Float64Array
+ * } TypedArray
+ */
+/**
+ * @typedef {Object} RefProxy
+ * @property {number} num
+ * @property {number} gen
+ */
+/**
+ * Document initialization / loading parameters object.
+ *
+ * @typedef {Object} DocumentInitParameters
+ * @property {string | URL} [url] - The URL of the PDF.
+ * @property {TypedArray | ArrayBuffer | Array<number> | string} [data] -
+ *   Binary PDF data.
+ *   Use TypedArrays (Uint8Array) to improve the memory usage. If PDF data is
+ *   BASE64-encoded, use `atob()` to convert it to a binary string first.
+ *
+ *   NOTE: If TypedArrays are used they will generally be transferred to the
+ *   worker-thread. This will help reduce main-thread memory usage, however
+ *   it will take ownership of the TypedArrays.
+ * @property {Object} [httpHeaders] - Basic authentication headers.
+ * @property {boolean} [withCredentials] - Indicates whether or not
+ *   cross-site Access-Control requests should be made using credentials such
+ *   as cookies or authorization headers. The default is `false`.
+ * @property {string} [password] - For decrypting password-protected PDFs.
+ * @property {number} [length] - The PDF file length. It's used for progress
+ *   reports and range requests operations.
+ * @property {PDFDataRangeTransport} [range] - Allows for using a custom range
+ *   transport implementation.
+ * @property {number} [rangeChunkSize] - Specify maximum number of bytes fetched
+ *   per range request. The default value is 65536 (= 2^16).
+ * @property {PDFWorker} [worker] - The worker that will be used for loading and
+ *   parsing the PDF data.
+ * @property {number} [verbosity] - Controls the logging level; the constants
+ *   from {@link VerbosityLevel} should be used.
+ * @property {string} [docBaseUrl] - The base URL of the document, used when
+ *   attempting to recover valid absolute URLs for annotations, and outline
+ *   items, that (incorrectly) only specify relative URLs.
+ * @property {string} [cMapUrl] - The URL where the predefined Adobe CMaps are
+ *   located. Include the trailing slash.
+ * @property {boolean} [cMapPacked] - Specifies if the Adobe CMaps are binary
+ *   packed or not. The default value is `true`.
+ * @property {Object} [CMapReaderFactory] - The factory that will be used when
+ *   reading built-in CMap files.
+ *   The default value is {DOMCMapReaderFactory}.
+ * @property {string} [iccUrl] - The URL where the predefined ICC profiles are
+ *   located. Include the trailing slash.
+ * @property {boolean} [useSystemFonts] - When `true`, fonts that aren't
+ *   embedded in the PDF document will fallback to a system font.
+ *   The default value is `true` in web environments and `false` in Node.js;
+ *   unless `disableFontFace === true` in which case this defaults to `false`
+ *   regardless of the environment (to prevent completely broken fonts).
+ * @property {string} [standardFontDataUrl] - The URL where the standard font
+ *   files are located. Include the trailing slash.
+ * @property {Object} [StandardFontDataFactory] - The factory that will be used
+ *   when reading the standard font files.
+ *   The default value is {DOMStandardFontDataFactory}.
+ * @property {string} [wasmUrl] - The URL where the wasm files are located.
+ *   Include the trailing slash.
+ * @property {Object} [WasmFactory] - The factory that will be used
+ *   when reading the wasm files.
+ *   The default value is {DOMWasmFactory}.
+ * @property {boolean} [useWorkerFetch] - Enable using the Fetch API in the
+ *   worker-thread when reading CMap and standard font files. When `true`,
+ *   the `CMapReaderFactory`, `StandardFontDataFactory`, and `WasmFactory`
+ *   options are ignored.
+ *   The default value is `true` in web environments and `false` in Node.js.
+ * @property {boolean} [useWasm] - Attempt to use WebAssembly in order to
+ *    improve e.g. image decoding performance.
+ *    The default value is `true`.
+ * @property {boolean} [stopAtErrors] - Reject certain promises, e.g.
+ *   `getOperatorList`, `getTextContent`, and `RenderTask`, when the associated
+ *   PDF data cannot be successfully parsed, instead of attempting to recover
+ *   whatever possible of the data. The default value is `false`.
+ * @property {number} [maxImageSize] - The maximum allowed image size in total
+ *   pixels, i.e. width * height. Images above this value will not be rendered.
+ *   Use -1 for no limit, which is also the default value.
+ * @property {boolean} [isEvalSupported] - Determines if we can evaluate strings
+ *   as JavaScript. Primarily used to improve performance of PDF functions.
+ *   The default value is `true`.
+ * @property {boolean} [isOffscreenCanvasSupported] - Determines if we can use
+ *   `OffscreenCanvas` in the worker. Primarily used to improve performance of
+ *   image conversion/rendering.
+ *   The default value is `true` in web environments and `false` in Node.js.
+ * @property {boolean} [isImageDecoderSupported] - Determines if we can use
+ *   `ImageDecoder` in the worker. Primarily used to improve performance of
+ *   image conversion/rendering.
+ *   The default value is `true` in web environments and `false` in Node.js.
+ *
+ *   NOTE: Also temporarily disabled in Chromium browsers, until we no longer
+ *   support the affected browser versions, because of various bugs:
+ *
+ *    - Crashes when using the BMP decoder with huge images, e.g. issue6741.pdf;
+ *      see https://issues.chromium.org/issues/374807001
+ *
+ *    - Broken images when using the JPEG decoder with images that have custom
+ *      colour profiles, e.g. GitHub discussion 19030;
+ *      see https://issues.chromium.org/issues/378869810
+ *
+ * @property {number} [canvasMaxAreaInBytes] - The integer value is used to
+ *   know when an image must be resized (uses `OffscreenCanvas` in the worker).
+ *   If it's -1 then a possibly slow algorithm is used to guess the max value.
+ * @property {boolean} [disableFontFace] - By default fonts are converted to
+ *   OpenType fonts and loaded via the Font Loading API or `@font-face` rules.
+ *   If disabled, fonts will be rendered using a built-in font renderer that
+ *   constructs the glyphs with primitive path commands.
+ *   The default value is `false` in web environments and `true` in Node.js.
+ * @property {boolean} [fontExtraProperties] - Include additional properties,
+ *   which are unused during rendering of PDF documents, when exporting the
+ *   parsed font data from the worker-thread. This may be useful for debugging
+ *   purposes (and backwards compatibility), but note that it will lead to
+ *   increased memory usage. The default value is `false`.
+ * @property {boolean} [enableXfa] - Render Xfa forms if any.
+ *   The default value is `false`.
+ * @property {HTMLDocument} [ownerDocument] - Specify an explicit document
+ *   context to create elements with and to load resources, such as fonts,
+ *   into. Defaults to the current document.
+ * @property {boolean} [disableRange] - Disable range request loading of PDF
+ *   files. When enabled, and if the server supports partial content requests,
+ *   then the PDF will be fetched in chunks. The default value is `false`.
+ * @property {boolean} [disableStream] - Disable streaming of PDF file data.
+ *   By default PDF.js attempts to load PDF files in chunks. The default value
+ *   is `false`.
+ * @property {boolean} [disableAutoFetch] - Disable pre-fetching of PDF file
+ *   data. When range requests are enabled PDF.js will automatically keep
+ *   fetching more data even if it isn't needed to display the current page.
+ *   The default value is `false`.
+ *
+ *   NOTE: It is also necessary to disable streaming, see above, in order for
+ *   disabling of pre-fetching to work correctly.
+ * @property {boolean} [pdfBug] - Enables special hooks for debugging PDF.js
+ *   (see `web/debugger.js`). The default value is `false`.
+ * @property {Object} [CanvasFactory] - The factory that will be used when
+ *    creating canvases. The default value is {DOMCanvasFactory}.
+ * @property {Object} [FilterFactory] - The factory that will be used to
+ *    create SVG filters when rendering some images on the main canvas.
+ *    The default value is {DOMFilterFactory}.
+ * @property {boolean} [enableHWA] - Enables hardware acceleration for
+ *   rendering. The default value is `false`.
+ */
+/**
+ * This is the main entry point for loading a PDF and interacting with it.
+ *
+ * NOTE: If a URL is used to fetch the PDF data a standard Fetch API call (or
+ * XHR as fallback) is used, which means it must follow same origin rules,
+ * e.g. no cross-domain requests without CORS.
+ *
+ * @param {string | URL | TypedArray | ArrayBuffer | DocumentInitParameters}
+ *   src - Can be a URL where a PDF file is located, a typed array (Uint8Array)
+ *         already populated with data, or a parameter object.
+ * @returns {PDFDocumentLoadingTask}
+ */
+export function getDocument(src?: string | URL | TypedArray | ArrayBuffer | DocumentInitParameters): PDFDocumentLoadingTask;
+/**
+ * Abstract class to support range requests file loading.
+ *
+ * NOTE: The TypedArrays passed to the constructor and relevant methods below
+ * will generally be transferred to the worker-thread. This will help reduce
+ * main-thread memory usage, however it will take ownership of the TypedArrays.
+ */
+export class PDFDataRangeTransport {
+    /**
+     * @param {number} length
+     * @param {Uint8Array|null} initialData
+     * @param {boolean} [progressiveDone]
+     * @param {string} [contentDispositionFilename]
+     */
+    constructor(length: number, initialData: Uint8Array | null, progressiveDone?: boolean, contentDispositionFilename?: string);
+    length: number;
+    initialData: Uint8Array<ArrayBufferLike> | null;
+    progressiveDone: boolean;
+    contentDispositionFilename: string;
+    /**
+     * @param {function} listener
+     */
+    addRangeListener(listener: Function): void;
+    /**
+     * @param {function} listener
+     */
+    addProgressListener(listener: Function): void;
+    /**
+     * @param {function} listener
+     */
+    addProgressiveReadListener(listener: Function): void;
+    /**
+     * @param {function} listener
+     */
+    addProgressiveDoneListener(listener: Function): void;
+    /**
+     * @param {number} begin
+     * @param {Uint8Array|null} chunk
+     */
+    onDataRange(begin: number, chunk: Uint8Array | null): void;
+    /**
+     * @param {number} loaded
+     * @param {number|undefined} total
+     */
+    onDataProgress(loaded: number, total: number | undefined): void;
+    /**
+     * @param {Uint8Array|null} chunk
+     */
+    onDataProgressiveRead(chunk: Uint8Array | null): void;
+    onDataProgressiveDone(): void;
+    transportReady(): void;
+    /**
+     * @param {number} begin
+     * @param {number} end
+     */
+    requestDataRange(begin: number, end: number): void;
+    abort(): void;
+    #private;
+}
+/**
+ * @typedef {Object} OnProgressParameters
+ * @property {number} loaded - Currently loaded number of bytes.
+ * @property {number} total - Total number of bytes in the PDF file.
+ */
+/**
+ * The loading task controls the operations required to load a PDF document
+ * (such as network requests) and provides a way to listen for completion,
+ * after which individual pages can be rendered.
+ */
+export class PDFDocumentLoadingTask {
+    static "__#59@#docId": number;
+    /**
+     * @private
+     */
+    private _capability;
+    /**
+     * @private
+     */
+    private _transport;
+    /**
+     * @private
+     */
+    private _worker;
+    /**
+     * Unique identifier for the document loading task.
+     * @type {string}
+     */
+    docId: string;
+    /**
+     * Whether the loading task is destroyed or not.
+     * @type {boolean}
+     */
+    destroyed: boolean;
+    /**
+     * Callback to request a password if a wrong or no password was provided.
+     * The callback receives two parameters: a function that should be called
+     * with the new password, and a reason (see {@link PasswordResponses}).
+     * @type {function}
+     */
+    onPassword: Function;
+    /**
+     * Callback to be able to monitor the loading progress of the PDF file
+     * (necessary to implement e.g. a loading bar).
+     * The callback receives an {@link OnProgressParameters} argument.
+     * @type {function}
+     */
+    onProgress: Function;
+    /**
+     * Promise for document loading task completion.
+     * @type {Promise<PDFDocumentProxy>}
+     */
+    get promise(): Promise<PDFDocumentProxy>;
+    /**
+     * Abort all network requests and destroy the worker.
+     * @returns {Promise<void>} A promise that is resolved when destruction is
+     *   completed.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Attempt to fetch the raw data of the PDF document, when e.g.
+     *  - An exception was thrown during document initialization.
+     *  - An `onPassword` callback is delaying initialization.
+     * @returns {Promise<Uint8Array>}
+     */
+    getData(): Promise<Uint8Array>;
+}
+/**
+ * Proxy to a `PDFDocument` in the worker thread.
+ */
+export class PDFDocumentProxy {
+    constructor(pdfInfo: any, transport: any);
+    _pdfInfo: any;
+    _transport: any;
+    /**
+     * @type {AnnotationStorage} Storage for annotation data in forms.
+     */
+    get annotationStorage(): AnnotationStorage;
+    /**
+     * @type {Object} The canvas factory instance.
+     */
+    get canvasFactory(): Object;
+    /**
+     * @type {Object} The filter factory instance.
+     */
+    get filterFactory(): Object;
+    /**
+     * @type {number} Total number of pages in the PDF file.
+     */
+    get numPages(): number;
+    /**
+     * @type {Array<string | null>} A (not guaranteed to be) unique ID to identify
+     *   the PDF document.
+     *   NOTE: The first element will always be defined for all PDF documents,
+     *   whereas the second element is only defined for *modified* PDF documents.
+     */
+    get fingerprints(): Array<string | null>;
+    /**
+     * @type {boolean} True if only XFA form.
+     */
+    get isPureXfa(): boolean;
+    /**
+     * NOTE: This is (mostly) intended to support printing of XFA forms.
+     *
+     * @type {Object | null} An object representing a HTML tree structure
+     *   to render the XFA, or `null` when no XFA form exists.
+     */
+    get allXfaHtml(): Object | null;
+    /**
+     * @param {number} pageNumber - The page number to get. The first page is 1.
+     * @returns {Promise<PDFPageProxy>} A promise that is resolved with
+     *   a {@link PDFPageProxy} object.
+     */
+    getPage(pageNumber: number): Promise<PDFPageProxy>;
+    /**
+     * @param {RefProxy} ref - The page reference.
+     * @returns {Promise<number>} A promise that is resolved with the page index,
+     *   starting from zero, that is associated with the reference.
+     */
+    getPageIndex(ref: RefProxy): Promise<number>;
+    /**
+     * @returns {Promise<Object<string, Array<any>>>} A promise that is resolved
+     *   with a mapping from named destinations to references.
+     *
+     * This can be slow for large documents. Use `getDestination` instead.
+     */
+    getDestinations(): Promise<{
+        [x: string]: Array<any>;
+    }>;
+    /**
+     * @param {string} id - The named destination to get.
+     * @returns {Promise<Array<any> | null>} A promise that is resolved with all
+     *   information of the given named destination, or `null` when the named
+     *   destination is not present in the PDF file.
+     */
+    getDestination(id: string): Promise<Array<any> | null>;
+    /**
+     * @returns {Promise<Array<string> | null>} A promise that is resolved with
+     *   an {Array} containing the page labels that correspond to the page
+     *   indexes, or `null` when no page labels are present in the PDF file.
+     */
+    getPageLabels(): Promise<Array<string> | null>;
+    /**
+     * @returns {Promise<string>} A promise that is resolved with a {string}
+     *   containing the page layout name.
+     */
+    getPageLayout(): Promise<string>;
+    /**
+     * @returns {Promise<string>} A promise that is resolved with a {string}
+     *   containing the page mode name.
+     */
+    getPageMode(): Promise<string>;
+    /**
+     * @returns {Promise<Object | null>} A promise that is resolved with an
+     *   {Object} containing the viewer preferences, or `null` when no viewer
+     *   preferences are present in the PDF file.
+     */
+    getViewerPreferences(): Promise<Object | null>;
+    /**
+     * @returns {Promise<any | null>} A promise that is resolved with an {Array}
+     *   containing the destination, or `null` when no open action is present
+     *   in the PDF.
+     */
+    getOpenAction(): Promise<any | null>;
+    /**
+     * @returns {Promise<any>} A promise that is resolved with a lookup table
+     *   for mapping named attachments to their content.
+     */
+    getAttachments(): Promise<any>;
+    /**
+     * @returns {Promise<Object | null>} A promise that is resolved with
+     *   an {Object} with the JavaScript actions:
+     *     - from the name tree.
+     *     - from A or AA entries in the catalog dictionary.
+     *   , or `null` if no JavaScript exists.
+     */
+    getJSActions(): Promise<Object | null>;
+    /**
+     * @typedef {Object} OutlineNode
+     * @property {string} title
+     * @property {boolean} bold
+     * @property {boolean} italic
+     * @property {Uint8ClampedArray} color - The color in RGB format to use for
+     *   display purposes.
+     * @property {string | Array<any> | null} dest
+     * @property {string | null} url
+     * @property {string | undefined} unsafeUrl
+     * @property {boolean | undefined} newWindow
+     * @property {number | undefined} count
+     * @property {Array<OutlineNode>} items
+     */
+    /**
+     * @returns {Promise<Array<OutlineNode>>} A promise that is resolved with an
+     *   {Array} that is a tree outline (if it has one) of the PDF file.
+     */
+    getOutline(): Promise<Array<{
+        title: string;
+        bold: boolean;
+        italic: boolean;
+        /**
+         * - The color in RGB format to use for
+         * display purposes.
+         */
+        color: Uint8ClampedArray;
+        dest: string | Array<any> | null;
+        url: string | null;
+        unsafeUrl: string | undefined;
+        newWindow: boolean | undefined;
+        count: number | undefined;
+        items: Array</*elided*/ any>;
+    }>>;
+    /**
+     * @typedef {Object} GetOptionalContentConfigParameters
+     * @property {string} [intent] - Determines the optional content groups that
+     *   are visible by default; valid values are:
+     *    - 'display' (viewable groups).
+     *    - 'print' (printable groups).
+     *    - 'any' (all groups).
+     *   The default value is 'display'.
+     */
+    /**
+     * @param {GetOptionalContentConfigParameters} [params] - Optional content
+     *   config parameters.
+     * @returns {Promise<OptionalContentConfig>} A promise that is resolved with
+     *   an {@link OptionalContentConfig} that contains all the optional content
+     *   groups (assuming that the document has any).
+     */
+    getOptionalContentConfig({ intent }?: {
+        /**
+         * - Determines the optional content groups that
+         * are visible by default; valid values are:
+         * - 'display' (viewable groups).
+         * - 'print' (printable groups).
+         * - 'any' (all groups).
+         * The default value is 'display'.
+         */
+        intent?: string | undefined;
+    }): Promise<OptionalContentConfig>;
+    /**
+     * @returns {Promise<Array<number> | null>} A promise that is resolved with
+     *   an {Array} that contains the permission flags for the PDF document, or
+     *   `null` when no permissions are present in the PDF file.
+     */
+    getPermissions(): Promise<Array<number> | null>;
+    /**
+     * @returns {Promise<{ info: Object, metadata: Metadata }>} A promise that is
+     *   resolved with an {Object} that has `info` and `metadata` properties.
+     *   `info` is an {Object} filled with anything available in the information
+     *   dictionary and similarly `metadata` is a {Metadata} object with
+     *   information from the metadata section of the PDF.
+     */
+    getMetadata(): Promise<{
+        info: Object;
+        metadata: Metadata;
+    }>;
+    /**
+     * @typedef {Object} MarkInfo
+     * Properties correspond to Table 321 of the PDF 32000-1:2008 spec.
+     * @property {boolean} Marked
+     * @property {boolean} UserProperties
+     * @property {boolean} Suspects
+     */
+    /**
+     * @returns {Promise<MarkInfo | null>} A promise that is resolved with
+     *   a {MarkInfo} object that contains the MarkInfo flags for the PDF
+     *   document, or `null` when no MarkInfo values are present in the PDF file.
+     */
+    getMarkInfo(): Promise<{
+        Marked: boolean;
+        UserProperties: boolean;
+        Suspects: boolean;
+    } | null>;
+    /**
+     * @returns {Promise<Uint8Array>} A promise that is resolved with a
+     *   {Uint8Array} containing the raw data of the PDF document.
+     */
+    getData(): Promise<Uint8Array>;
+    /**
+     * @returns {Promise<Uint8Array>} A promise that is resolved with a
+     *   {Uint8Array} containing the full data of the saved document.
+     */
+    saveDocument(): Promise<Uint8Array>;
+    /**
+     * @returns {Promise<{ length: number }>} A promise that is resolved when the
+     *   document's data is loaded. It is resolved with an {Object} that contains
+     *   the `length` property that indicates size of the PDF data in bytes.
+     */
+    getDownloadInfo(): Promise<{
+        length: number;
+    }>;
+    /**
+     * Cleans up resources allocated by the document on both the main and worker
+     * threads.
+     *
+     * NOTE: Do not, under any circumstances, call this method when rendering is
+     * currently ongoing since that may lead to rendering errors.
+     *
+     * @param {boolean} [keepLoadedFonts] - Let fonts remain attached to the DOM.
+     *   NOTE: This will increase persistent memory usage, hence don't use this
+     *   option unless absolutely necessary. The default value is `false`.
+     * @returns {Promise} A promise that is resolved when clean-up has finished.
+     */
+    cleanup(keepLoadedFonts?: boolean): Promise<any>;
+    /**
+     * Destroys the current document instance and terminates the worker.
+     */
+    destroy(): Promise<void>;
+    /**
+     * @param {RefProxy} ref - The page reference.
+     * @returns {number | null} The page number, if it's cached.
+     */
+    cachedPageNumber(ref: RefProxy): number | null;
+    /**
+     * @type {DocumentInitParameters} A subset of the current
+     *   {DocumentInitParameters}, which are needed in the viewer.
+     */
+    get loadingParams(): DocumentInitParameters;
+    /**
+     * @type {PDFDocumentLoadingTask} The loadingTask for the current document.
+     */
+    get loadingTask(): PDFDocumentLoadingTask;
+    /**
+     * @returns {Promise<Object<string, Array<Object>> | null>} A promise that is
+     *   resolved with an {Object} containing /AcroForm field data for the JS
+     *   sandbox, or `null` when no field data is present in the PDF file.
+     */
+    getFieldObjects(): Promise<{
+        [x: string]: Array<Object>;
+    } | null>;
+    /**
+     * @returns {Promise<boolean>} A promise that is resolved with `true`
+     *   if some /AcroForm fields have JavaScript actions.
+     */
+    hasJSActions(): Promise<boolean>;
+    /**
+     * @returns {Promise<Array<string> | null>} A promise that is resolved with an
+     *   {Array<string>} containing IDs of annotations that have a calculation
+     *   action, or `null` when no such annotations are present in the PDF file.
+     */
+    getCalculationOrderIds(): Promise<Array<string> | null>;
+}
+/**
+ * Page getViewport parameters.
+ *
+ * @typedef {Object} GetViewportParameters
+ * @property {number} scale - The desired scale of the viewport.
+ * @property {number} [rotation] - The desired rotation, in degrees, of
+ *   the viewport. If omitted it defaults to the page rotation.
+ * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset.
+ *   The default value is `0`.
+ * @property {number} [offsetY] - The vertical, i.e. y-axis, offset.
+ *   The default value is `0`.
+ * @property {boolean} [dontFlip] - If true, the y-axis will not be
+ *   flipped. The default value is `false`.
+ */
+/**
+ * Page getTextContent parameters.
+ *
+ * @typedef {Object} getTextContentParameters
+ * @property {boolean} [includeMarkedContent] - When true include marked
+ *   content items in the items array of TextContent. The default is `false`.
+ * @property {boolean} [disableNormalization] - When true the text is *not*
+ *   normalized in the worker-thread. The default is `false`.
+ */
+/**
+ * Page text content.
+ *
+ * @typedef {Object} TextContent
+ * @property {Array<TextItem | TextMarkedContent>} items - Array of
+ *   {@link TextItem} and {@link TextMarkedContent} objects. TextMarkedContent
+ *   items are included when includeMarkedContent is true.
+ * @property {Object<string, TextStyle>} styles - {@link TextStyle} objects,
+ *   indexed by font name.
+ * @property {string | null} lang - The document /Lang attribute.
+ */
+/**
+ * Page text content part.
+ *
+ * @typedef {Object} TextItem
+ * @property {string} str - Text content.
+ * @property {string} dir - Text direction: 'ttb', 'ltr' or 'rtl'.
+ * @property {Array<any>} transform - Transformation matrix.
+ * @property {number} width - Width in device space.
+ * @property {number} height - Height in device space.
+ * @property {string} fontName - Font name used by PDF.js for converted font.
+ * @property {boolean} hasEOL - Indicating if the text content is followed by a
+ *   line-break.
+ */
+/**
+ * Page text marked content part.
+ *
+ * @typedef {Object} TextMarkedContent
+ * @property {string} type - Either 'beginMarkedContent',
+ *   'beginMarkedContentProps', or 'endMarkedContent'.
+ * @property {string} id - The marked content identifier. Only used for type
+ *   'beginMarkedContentProps'.
+ */
+/**
+ * Text style.
+ *
+ * @typedef {Object} TextStyle
+ * @property {number} ascent - Font ascent.
+ * @property {number} descent - Font descent.
+ * @property {boolean} vertical - Whether or not the text is in vertical mode.
+ * @property {string} fontFamily - The possible font family.
+ */
+/**
+ * Page annotation parameters.
+ *
+ * @typedef {Object} GetAnnotationsParameters
+ * @property {string} [intent] - Determines the annotations that are fetched,
+ *   can be 'display' (viewable annotations), 'print' (printable annotations),
+ *   or 'any' (all annotations). The default value is 'display'.
+ */
+/**
+ * Page render parameters.
+ *
+ * @typedef {Object} RenderParameters
+ * @property {CanvasRenderingContext2D} canvasContext - 2D context of a DOM
+ *   Canvas object for backwards compatibility; it is recommended to use the
+ *   `canvas` parameter instead.
+ *   If the context must absolutely be used to render the page, the canvas must
+ *   be null.
+ * @property {HTMLCanvasElement|null} canvas - A DOM Canvas object. The default
+ *   value is the canvas associated with the `canvasContext` parameter if no
+ *   value is provided explicitly.
+ * @property {PageViewport} viewport - Rendering viewport obtained by calling
+ *   the `PDFPageProxy.getViewport` method.
+ * @property {string} [intent] - Rendering intent, can be 'display', 'print',
+ *   or 'any'. The default value is 'display'.
+ * @property {number} [annotationMode] Controls which annotations are rendered
+ *   onto the canvas, for annotations with appearance-data; the values from
+ *   {@link AnnotationMode} should be used. The following values are supported:
+ *    - `AnnotationMode.DISABLE`, which disables all annotations.
+ *    - `AnnotationMode.ENABLE`, which includes all possible annotations (thus
+ *      it also depends on the `intent`-option, see above).
+ *    - `AnnotationMode.ENABLE_FORMS`, which excludes annotations that contain
+ *      interactive form elements (those will be rendered in the display layer).
+ *    - `AnnotationMode.ENABLE_STORAGE`, which includes all possible annotations
+ *      (as above) but where interactive form elements are updated with data
+ *      from the {@link AnnotationStorage}-instance; useful e.g. for printing.
+ *   The default value is `AnnotationMode.ENABLE`.
+ * @property {Array<any>} [transform] - Additional transform, applied just
+ *   before viewport transform.
+ * @property {CanvasGradient | CanvasPattern | string} [background] - Background
+ *   to use for the canvas.
+ *   Any valid `canvas.fillStyle` can be used: a `DOMString` parsed as CSS
+ *   <color> value, a `CanvasGradient` object (a linear or radial gradient) or
+ *   a `CanvasPattern` object (a repetitive image). The default value is
+ *   'rgb(255,255,255)'.
+ *
+ *   NOTE: This option may be partially, or completely, ignored when the
+ *   `pageColors`-option is used.
+ * @property {Object} [pageColors] - Overwrites background and foreground colors
+ *   with user defined ones in order to improve readability in high contrast
+ *   mode.
+ * @property {Promise<OptionalContentConfig>} [optionalContentConfigPromise] -
+ *   A promise that should resolve with an {@link OptionalContentConfig}
+ *   created from `PDFDocumentProxy.getOptionalContentConfig`. If `null`,
+ *   the configuration will be fetched automatically with the default visibility
+ *   states set.
+ * @property {Map<string, HTMLCanvasElement>} [annotationCanvasMap] - Map some
+ *   annotation ids with canvases used to render them.
+ * @property {PrintAnnotationStorage} [printAnnotationStorage]
+ * @property {boolean} [isEditing] - Render the page in editing mode.
+ */
+/**
+ * Page getOperatorList parameters.
+ *
+ * @typedef {Object} GetOperatorListParameters
+ * @property {string} [intent] - Rendering intent, can be 'display', 'print',
+ *   or 'any'. The default value is 'display'.
+ * @property {number} [annotationMode] Controls which annotations are included
+ *   in the operatorList, for annotations with appearance-data; the values from
+ *   {@link AnnotationMode} should be used. The following values are supported:
+ *    - `AnnotationMode.DISABLE`, which disables all annotations.
+ *    - `AnnotationMode.ENABLE`, which includes all possible annotations (thus
+ *      it also depends on the `intent`-option, see above).
+ *    - `AnnotationMode.ENABLE_FORMS`, which excludes annotations that contain
+ *      interactive form elements (those will be rendered in the display layer).
+ *    - `AnnotationMode.ENABLE_STORAGE`, which includes all possible annotations
+ *      (as above) but where interactive form elements are updated with data
+ *      from the {@link AnnotationStorage}-instance; useful e.g. for printing.
+ *   The default value is `AnnotationMode.ENABLE`.
+ * @property {PrintAnnotationStorage} [printAnnotationStorage]
+ * @property {boolean} [isEditing] - Render the page in editing mode.
+ */
+/**
+ * Structure tree node. The root node will have a role "Root".
+ *
+ * @typedef {Object} StructTreeNode
+ * @property {Array<StructTreeNode | StructTreeContent>} children - Array of
+ *   {@link StructTreeNode} and {@link StructTreeContent} objects.
+ * @property {string} role - element's role, already mapped if a role map exists
+ * in the PDF.
+ */
+/**
+ * Structure tree content.
+ *
+ * @typedef {Object} StructTreeContent
+ * @property {string} type - either "content" for page and stream structure
+ *   elements or "object" for object references.
+ * @property {string} id - unique id that will map to the text layer.
+ */
+/**
+ * PDF page operator list.
+ *
+ * @typedef {Object} PDFOperatorList
+ * @property {Array<number>} fnArray - Array containing the operator functions.
+ * @property {Array<any>} argsArray - Array containing the arguments of the
+ *   functions.
+ */
+/**
+ * Proxy to a `PDFPage` in the worker thread.
+ */
+export class PDFPageProxy {
+    constructor(pageIndex: any, pageInfo: any, transport: any, pdfBug?: boolean);
+    _pageIndex: any;
+    _pageInfo: any;
+    _transport: any;
+    _stats: StatTimer | null;
+    _pdfBug: boolean;
+    /** @type {PDFObjects} */
+    commonObjs: PDFObjects;
+    objs: PDFObjects;
+    _intentStates: Map<any, any>;
+    destroyed: boolean;
+    /**
+     * @type {number} Page number of the page. First page is 1.
+     */
+    get pageNumber(): number;
+    /**
+     * @type {number} The number of degrees the page is rotated clockwise.
+     */
+    get rotate(): number;
+    /**
+     * @type {RefProxy | null} The reference that points to this page.
+     */
+    get ref(): RefProxy | null;
+    /**
+     * @type {number} The default size of units in 1/72nds of an inch.
+     */
+    get userUnit(): number;
+    /**
+     * @type {Array<number>} An array of the visible portion of the PDF page in
+     *   user space units [x1, y1, x2, y2].
+     */
+    get view(): Array<number>;
+    /**
+     * @param {GetViewportParameters} params - Viewport parameters.
+     * @returns {PageViewport} Contains 'width' and 'height' properties
+     *   along with transforms required for rendering.
+     */
+    getViewport({ scale, rotation, offsetX, offsetY, dontFlip, }?: GetViewportParameters): PageViewport;
+    /**
+     * @param {GetAnnotationsParameters} [params] - Annotation parameters.
+     * @returns {Promise<Array<any>>} A promise that is resolved with an
+     *   {Array} of the annotation objects.
+     */
+    getAnnotations({ intent }?: GetAnnotationsParameters): Promise<Array<any>>;
+    /**
+     * @returns {Promise<Object>} A promise that is resolved with an
+     *   {Object} with JS actions.
+     */
+    getJSActions(): Promise<Object>;
+    /**
+     * @type {Object} The filter factory instance.
+     */
+    get filterFactory(): Object;
+    /**
+     * @type {boolean} True if only XFA form.
+     */
+    get isPureXfa(): boolean;
+    /**
+     * @returns {Promise<Object | null>} A promise that is resolved with
+     *   an {Object} with a fake DOM object (a tree structure where elements
+     *   are {Object} with a name, attributes (class, style, ...), value and
+     *   children, very similar to a HTML DOM tree), or `null` if no XFA exists.
+     */
+    getXfa(): Promise<Object | null>;
+    /**
+     * Begins the process of rendering a page to the desired context.
+     *
+     * @param {RenderParameters} params - Page render parameters.
+     * @returns {RenderTask} An object that contains a promise that is
+     *   resolved when the page finishes rendering.
+     */
+    render({ canvasContext, canvas, viewport, intent, annotationMode, transform, background, optionalContentConfigPromise, annotationCanvasMap, pageColors, printAnnotationStorage, isEditing, }: RenderParameters): RenderTask;
+    /**
+     * @param {GetOperatorListParameters} params - Page getOperatorList
+     *   parameters.
+     * @returns {Promise<PDFOperatorList>} A promise resolved with an
+     *   {@link PDFOperatorList} object that represents the page's operator list.
+     */
+    getOperatorList({ intent, annotationMode, printAnnotationStorage, isEditing, }?: GetOperatorListParameters): Promise<PDFOperatorList>;
+    /**
+     * NOTE: All occurrences of whitespace will be replaced by
+     * standard spaces (0x20).
+     *
+     * @param {getTextContentParameters} params - getTextContent parameters.
+     * @returns {ReadableStream} Stream for reading text content chunks.
+     */
+    streamTextContent({ includeMarkedContent, disableNormalization, }?: getTextContentParameters): ReadableStream;
+    /**
+     * NOTE: All occurrences of whitespace will be replaced by
+     * standard spaces (0x20).
+     *
+     * @param {getTextContentParameters} params - getTextContent parameters.
+     * @returns {Promise<TextContent>} A promise that is resolved with a
+     *   {@link TextContent} object that represents the page's text content.
+     */
+    getTextContent(params?: getTextContentParameters): Promise<TextContent>;
+    /**
+     * @returns {Promise<StructTreeNode>} A promise that is resolved with a
+     *   {@link StructTreeNode} object that represents the page's structure tree,
+     *   or `null` when no structure tree is present for the current page.
+     */
+    getStructTree(): Promise<StructTreeNode>;
+    /**
+     * Destroys the page object.
+     * @private
+     */
+    private _destroy;
+    /**
+     * Cleans up resources allocated by the page.
+     *
+     * @param {boolean} [resetStats] - Reset page stats, if enabled.
+     *   The default value is `false`.
+     * @returns {boolean} Indicates if clean-up was successfully run.
+     */
+    cleanup(resetStats?: boolean): boolean;
+    /**
+     * @private
+     */
+    private _startRenderPage;
+    /**
+     * @private
+     */
+    private _renderPageChunk;
+    /**
+     * @private
+     */
+    private _pumpOperatorList;
+    /**
+     * @private
+     */
+    private _abortOperatorList;
+    /**
+     * @type {StatTimer | null} Returns page stats, if enabled; returns `null`
+     *   otherwise.
+     */
+    get stats(): StatTimer | null;
+    #private;
+}
+/**
+ * @typedef {Object} PDFWorkerParameters
+ * @property {string} [name] - The name of the worker.
+ * @property {Worker} [port] - The `workerPort` object.
+ * @property {number} [verbosity] - Controls the logging level;
+ *   the constants from {@link VerbosityLevel} should be used.
+ */
+/**
+ * PDF.js web worker abstraction that controls the instantiation of PDF
+ * documents. Message handlers are used to pass information from the main
+ * thread to the worker thread and vice versa. If the creation of a web
+ * worker is not possible, a "fake" worker will be used instead.
+ *
+ * @param {PDFWorkerParameters} params - The worker initialization parameters.
+ */
+export class PDFWorker {
+    static "__#62@#fakeWorkerId": number;
+    static "__#62@#isWorkerDisabled": boolean;
+    static "__#62@#workerPorts": WeakMap<object, any>;
+    /**
+     * @param {PDFWorkerParameters} params - The worker initialization parameters.
+     * @returns {PDFWorker}
+     */
+    static create(params: PDFWorkerParameters): PDFWorker;
+    /**
+     * The current `workerSrc`, when it exists.
+     * @type {string}
+     */
+    static get workerSrc(): string;
+    static get "__#62@#mainThreadWorkerMessageHandler"(): any;
+    static get _setupFakeWorkerGlobal(): any;
+    constructor({ name, port, verbosity, }?: {
+        name?: null | undefined;
+        port?: null | undefined;
+        verbosity?: number | undefined;
+    });
+    name: any;
+    destroyed: boolean;
+    verbosity: number;
+    /**
+     * Promise for worker initialization completion.
+     * @type {Promise<void>}
+     */
+    get promise(): Promise<void>;
+    /**
+     * The current `workerPort`, when it exists.
+     * @type {Worker}
+     */
+    get port(): Worker;
+    /**
+     * The current MessageHandler-instance.
+     * @type {MessageHandler}
+     */
+    get messageHandler(): MessageHandler;
+    /**
+     * Destroys the worker instance.
+     */
+    destroy(): void;
+    #private;
+}
+/**
+ * Allows controlling of the rendering tasks.
+ */
+export class RenderTask {
+    constructor(internalRenderTask: any);
+    /**
+     * Callback for incremental rendering -- a function that will be called
+     * each time the rendering is paused.  To continue rendering call the
+     * function that is the first argument to the callback.
+     * @type {function}
+     */
+    onContinue: Function;
+    /**
+     * A function that will be synchronously called when the rendering tasks
+     * finishes with an error (either because of an actual error, or because the
+     * rendering is cancelled).
+     *
+     * @type {function}
+     * @param {Error} error
+     */
+    onError: Function;
+    /**
+     * Promise for rendering task completion.
+     * @type {Promise<void>}
+     */
+    get promise(): Promise<void>;
+    /**
+     * Cancels the rendering task. If the task is currently rendering it will
+     * not be cancelled until graphics pauses with a timeout. The promise that
+     * this object extends will be rejected when cancelled.
+     *
+     * @param {number} [extraDelay]
+     */
+    cancel(extraDelay?: number): void;
+    /**
+     * Whether form fields are rendered separately from the main operatorList.
+     * @type {boolean}
+     */
+    get separateAnnots(): boolean;
+    #private;
+}
+/** @type {string} */
+export const version: string;
+import { PageViewport } from "./display_utils.js";
+import { OptionalContentConfig } from "./optional_content_config.js";
+import { PrintAnnotationStorage } from "./annotation_storage.js";
+import { AnnotationStorage } from "./annotation_storage.js";
+import { Metadata } from "./metadata.js";
+import { StatTimer } from "./display_utils.js";
+import { PDFObjects } from "./pdf_objects.js";
+import { MessageHandler } from "../shared/message_handler.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/api_utils.d.ts

@@ -0,0 +1,13 @@
+export function getDataProp(val: any): Uint8Array<any>;
+export function getFactoryUrlProp(val: any): string | null;
+export function getUrlProp(val: any): string | null;
+export function isNameProxy(v: any): boolean;
+export function isRefProxy(v: any): boolean;
+export const isValidExplicitDest: (dest?: any) => boolean;
+export class LoopbackPort {
+    postMessage(obj: any, transfer: any): void;
+    addEventListener(name: any, listener: any, options?: null): void;
+    removeEventListener(name: any, listener: any): void;
+    terminate(): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/canvas.d.ts

@@ -0,0 +1,205 @@
+export class CanvasGraphics {
+    constructor(canvasCtx: any, commonObjs: any, objs: any, canvasFactory: any, filterFactory: any, { optionalContentConfig, markedContentStack }: {
+        optionalContentConfig: any;
+        markedContentStack?: null | undefined;
+    }, annotationCanvasMap: any, pageColors: any);
+    ctx: any;
+    current: CanvasExtraState;
+    stateStack: any[];
+    pendingClip: {} | {} | null;
+    pendingEOFill: boolean;
+    res: any;
+    xobjs: any;
+    commonObjs: any;
+    objs: any;
+    canvasFactory: any;
+    filterFactory: any;
+    groupStack: any[];
+    baseTransform: any;
+    baseTransformStack: any[];
+    groupLevel: number;
+    smaskStack: any[];
+    smaskCounter: number;
+    tempSMask: any;
+    suspendedCtx: any;
+    contentVisible: boolean;
+    markedContentStack: never[];
+    optionalContentConfig: any;
+    cachedCanvases: CachedCanvases;
+    cachedPatterns: Map<any, any>;
+    annotationCanvasMap: any;
+    viewportScale: number;
+    outputScaleX: number;
+    outputScaleY: number;
+    pageColors: any;
+    _cachedScaleForStroking: number[];
+    _cachedGetSinglePixelWidth: number | null;
+    _cachedBitmapsMap: Map<any, any>;
+    getObject(data: any, fallback?: null): any;
+    beginDrawing({ transform, viewport, transparency, background, }: {
+        transform: any;
+        viewport: any;
+        transparency?: boolean | undefined;
+        background?: null | undefined;
+    }): void;
+    compositeCtx: any;
+    transparentCanvas: any;
+    executeOperatorList(operatorList: any, executionStartIdx: any, continueCallback: any, stepper: any): any;
+    endDrawing(): void;
+    _scaleImage(img: any, inverseTransform: any): {
+        img: any;
+        paintWidth: any;
+        paintHeight: any;
+    };
+    _createMaskCanvas(img: any): {
+        canvas: any;
+        offsetX: number;
+        offsetY: number;
+    };
+    setLineWidth(width: any): void;
+    setLineCap(style: any): void;
+    setLineJoin(style: any): void;
+    setMiterLimit(limit: any): void;
+    setDash(dashArray: any, dashPhase: any): void;
+    setRenderingIntent(intent: any): void;
+    setFlatness(flatness: any): void;
+    setGState(states: any): void;
+    get inSMaskMode(): boolean;
+    checkSMaskState(): void;
+    /**
+     * Soft mask mode takes the current main drawing canvas and replaces it with
+     * a temporary canvas. Any drawing operations that happen on the temporary
+     * canvas need to be composed with the main canvas that was suspended (see
+     * `compose()`). The temporary canvas also duplicates many of its operations
+     * on the suspended canvas to keep them in sync, so that when the soft mask
+     * mode ends any clipping paths or transformations will still be active and in
+     * the right order on the canvas' graphics state stack.
+     */
+    beginSMaskMode(): void;
+    endSMaskMode(): void;
+    compose(dirtyBox: any): void;
+    composeSMask(ctx: any, smask: any, layerCtx: any, layerBox: any): void;
+    genericComposeSMask(maskCtx: any, layerCtx: any, width: any, height: any, subtype: any, backdrop: any, transferMap: any, layerOffsetX: any, layerOffsetY: any, maskOffsetX: any, maskOffsetY: any): void;
+    save(): void;
+    restore(): void;
+    transform(a: any, b: any, c: any, d: any, e: any, f: any): void;
+    constructPath(op: any, data: any, minMax: any): void;
+    closePath(): void;
+    stroke(path: any, consumePath?: boolean): void;
+    closeStroke(path: any): void;
+    fill(path: any, consumePath?: boolean): void;
+    eoFill(path: any): void;
+    fillStroke(path: any): void;
+    eoFillStroke(path: any): void;
+    closeFillStroke(path: any): void;
+    closeEOFillStroke(path: any): void;
+    endPath(path: any): void;
+    rawFillPath(path: any): void;
+    clip(): void;
+    eoClip(): void;
+    beginText(): void;
+    endText(): void;
+    setCharSpacing(spacing: any): void;
+    setWordSpacing(spacing: any): void;
+    setHScale(scale: any): void;
+    setLeading(leading: any): void;
+    setFont(fontRefName: any, size: any): void;
+    setTextRenderingMode(mode: any): void;
+    setTextRise(rise: any): void;
+    moveText(x: any, y: any): void;
+    setLeadingMoveText(x: any, y: any): void;
+    setTextMatrix(matrix: any): void;
+    nextLine(): void;
+    paintChar(character: any, x: any, y: any, patternFillTransform: any, patternStrokeTransform: any): void;
+    get isFontSubpixelAAEnabled(): any;
+    showText(glyphs: any): void;
+    showType3Text(glyphs: any): void;
+    setCharWidth(xWidth: any, yWidth: any): void;
+    setCharWidthAndBounds(xWidth: any, yWidth: any, llx: any, lly: any, urx: any, ury: any): void;
+    getColorN_Pattern(IR: any): any;
+    setStrokeColorN(...args: any[]): void;
+    setFillColorN(...args: any[]): void;
+    setStrokeRGBColor(color: any): void;
+    setStrokeTransparent(): void;
+    setFillRGBColor(color: any): void;
+    setFillTransparent(): void;
+    _getPattern(objId: any, matrix?: null): any;
+    shadingFill(objId: any): void;
+    beginInlineImage(): void;
+    beginImageData(): void;
+    paintFormXObjectBegin(matrix: any, bbox: any): void;
+    paintFormXObjectEnd(): void;
+    beginGroup(group: any): void;
+    endGroup(group: any): void;
+    beginAnnotation(id: any, rect: any, transform: any, matrix: any, hasOwnCanvas: any): void;
+    annotationCanvas: any;
+    endAnnotation(): void;
+    paintImageMaskXObject(img: any): void;
+    paintImageMaskXObjectRepeat(img: any, scaleX: any, skewX: number | undefined, skewY: number | undefined, scaleY: any, positions: any): void;
+    paintImageMaskXObjectGroup(images: any): void;
+    paintImageXObject(objId: any): void;
+    paintImageXObjectRepeat(objId: any, scaleX: any, scaleY: any, positions: any): void;
+    applyTransferMapsToCanvas(ctx: any): any;
+    applyTransferMapsToBitmap(imgData: any): any;
+    paintInlineImageXObject(imgData: any): void;
+    paintInlineImageXObjectGroup(imgData: any, map: any): void;
+    paintSolidColorImageMask(): void;
+    markPoint(tag: any): void;
+    markPointProps(tag: any, properties: any): void;
+    beginMarkedContent(tag: any): void;
+    beginMarkedContentProps(tag: any, properties: any): void;
+    endMarkedContent(): void;
+    beginCompat(): void;
+    endCompat(): void;
+    consumePath(path: any, clipBox: any): void;
+    getSinglePixelWidth(): number;
+    getScaleForStroking(): number[];
+    rescaleAndStroke(path: any, saveRestore: any): void;
+    isContentVisible(): boolean;
+    #private;
+}
+declare class CanvasExtraState {
+    constructor(width: any, height: any);
+    alphaIsShape: boolean;
+    fontSize: number;
+    fontSizeScale: number;
+    textMatrix: null;
+    textMatrixScale: number;
+    fontMatrix: number[];
+    leading: number;
+    x: number;
+    y: number;
+    lineX: number;
+    lineY: number;
+    charSpacing: number;
+    wordSpacing: number;
+    textHScale: number;
+    textRenderingMode: number;
+    textRise: number;
+    fillColor: string;
+    strokeColor: string;
+    patternFill: boolean;
+    patternStroke: boolean;
+    fillAlpha: number;
+    strokeAlpha: number;
+    lineWidth: number;
+    activeSMask: null;
+    transferMaps: string;
+    clipBox: Float32Array<ArrayBuffer>;
+    minMax: Float32Array<ArrayBuffer>;
+    clone(): any;
+    getPathBoundingBox(pathType?: string, transform?: null): Float32Array<ArrayBuffer>;
+    updateClipFromPath(): void;
+    isEmptyClip(): boolean;
+    startNewPathAndClipBox(box: any): void;
+    getClippedPathBoundingBox(pathType?: string, transform?: null): number[] | null;
+}
+declare class CachedCanvases {
+    constructor(canvasFactory: any);
+    canvasFactory: any;
+    cache: any;
+    getCanvas(id: any, width: any, height: any): any;
+    delete(id: any): void;
+    clear(): void;
+}
+export {};

tools/ui/node_modules/pdfjs-dist/types/src/display/canvas_factory.d.ts

@@ -0,0 +1,27 @@
+export class BaseCanvasFactory {
+    constructor({ enableHWA }: {
+        enableHWA?: boolean | undefined;
+    });
+    create(width: any, height: any): {
+        canvas: void;
+        context: any;
+    };
+    reset(canvasAndContext: any, width: any, height: any): void;
+    destroy(canvasAndContext: any): void;
+    /**
+     * @ignore
+     */
+    _createCanvas(width: any, height: any): void;
+    #private;
+}
+export class DOMCanvasFactory extends BaseCanvasFactory {
+    constructor({ ownerDocument, enableHWA }: {
+        ownerDocument?: Document | undefined;
+        enableHWA?: boolean | undefined;
+    });
+    _document: Document;
+    /**
+     * @ignore
+     */
+    _createCanvas(width: any, height: any): HTMLCanvasElement;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/cmap_reader_factory.d.ts

@@ -0,0 +1,25 @@
+export class BaseCMapReaderFactory {
+    constructor({ baseUrl, isCompressed }: {
+        baseUrl?: null | undefined;
+        isCompressed?: boolean | undefined;
+    });
+    baseUrl: any;
+    isCompressed: boolean;
+    fetch({ name }: {
+        name: any;
+    }): Promise<{
+        cMapData: Uint8Array<ArrayBufferLike>;
+        isCompressed: boolean;
+    }>;
+    /**
+     * @ignore
+     * @returns {Promise<Uint8Array>}
+     */
+    _fetch(url: any): Promise<Uint8Array>;
+}
+export class DOMCMapReaderFactory extends BaseCMapReaderFactory {
+    /**
+     * @ignore
+     */
+    _fetch(url: any): Promise<Uint8Array<any>>;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/content_disposition.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Extract file name from the Content-Disposition HTTP response header.
+ *
+ * @param {string} contentDisposition
+ * @returns {string} Filename, if found in the Content-Disposition header.
+ */
+export function getFilenameFromContentDispositionHeader(contentDisposition: string): string;

tools/ui/node_modules/pdfjs-dist/types/src/display/display_utils.d.ts

@@ -0,0 +1,258 @@
+export type PageViewportParameters = {
+    /**
+     * - The xMin, yMin, xMax and
+     * yMax coordinates.
+     */
+    viewBox: Array<number>;
+    /**
+     * - The size of units.
+     */
+    userUnit: number;
+    /**
+     * - The scale of the viewport.
+     */
+    scale: number;
+    /**
+     * - The rotation, in degrees, of the viewport.
+     */
+    rotation: number;
+    /**
+     * - The horizontal, i.e. x-axis, offset. The
+     * default value is `0`.
+     */
+    offsetX?: number | undefined;
+    /**
+     * - The vertical, i.e. y-axis, offset. The
+     * default value is `0`.
+     */
+    offsetY?: number | undefined;
+    /**
+     * - If true, the y-axis will not be flipped.
+     * The default value is `false`.
+     */
+    dontFlip?: boolean | undefined;
+};
+export type PageViewportCloneParameters = {
+    /**
+     * - The scale, overriding the one in the cloned
+     * viewport. The default value is `this.scale`.
+     */
+    scale?: number | undefined;
+    /**
+     * - The rotation, in degrees, overriding the one
+     * in the cloned viewport. The default value is `this.rotation`.
+     */
+    rotation?: number | undefined;
+    /**
+     * - The horizontal, i.e. x-axis, offset.
+     * The default value is `this.offsetX`.
+     */
+    offsetX?: number | undefined;
+    /**
+     * - The vertical, i.e. y-axis, offset.
+     * The default value is `this.offsetY`.
+     */
+    offsetY?: number | undefined;
+    /**
+     * - If true, the x-axis will not be flipped.
+     * The default value is `false`.
+     */
+    dontFlip?: boolean | undefined;
+};
+export function deprecated(details: any): void;
+export function fetchData(url: any, type?: string): Promise<any>;
+export function getColorValues(colors: any): void;
+export function getCurrentTransform(ctx: any): any[];
+export function getCurrentTransformInverse(ctx: any): any[];
+/**
+ * Gets the filename from a given URL.
+ * @param {string} url
+ * @returns {string}
+ */
+export function getFilenameFromUrl(url: string): string;
+/**
+ * Returns the filename or guessed filename from the url (see issue 3455).
+ * @param {string} url - The original PDF location.
+ * @param {string} defaultFilename - The value returned if the filename is
+ *   unknown, or the protocol is unsupported.
+ * @returns {string} Guessed PDF filename.
+ */
+export function getPdfFilenameFromUrl(url: string, defaultFilename?: string): string;
+export function getRGB(color: any): any;
+/**
+ * NOTE: This is (mostly) intended to support printing of XFA forms.
+ */
+export function getXfaPageViewport(xfaPage: any, { scale, rotation }: {
+    scale?: number | undefined;
+    rotation?: number | undefined;
+}): PageViewport;
+export function isDataScheme(url: any): boolean;
+export function isPdfFile(filename: any): boolean;
+export function isValidFetchUrl(url: any, baseUrl: any): boolean;
+/**
+ * Event handler to suppress context menu.
+ */
+export function noContextMenu(e: any): void;
+/**
+ * Scale factors for the canvas, necessary with HiDPI displays.
+ */
+export class OutputScale {
+    static get pixelRatio(): number;
+    static capPixels(maxPixels: any, capAreaFactor: any): any;
+    /**
+     * @type {number} Horizontal scale.
+     */
+    sx: number;
+    /**
+     * @type {number} Vertical scale.
+     */
+    sy: number;
+    /**
+     * @type {boolean} Returns `true` when scaling is required, `false` otherwise.
+     */
+    get scaled(): boolean;
+    /**
+     * @type {boolean} Returns `true` when scaling is symmetric,
+     *   `false` otherwise.
+     */
+    get symmetric(): boolean;
+    /**
+     * @returns {boolean} Returns `true` if scaling was limited,
+     *   `false` otherwise.
+     */
+    limitCanvas(width: any, height: any, maxPixels: any, maxDim: any, capAreaFactor?: number): boolean;
+}
+/**
+ * @typedef {Object} PageViewportParameters
+ * @property {Array<number>} viewBox - The xMin, yMin, xMax and
+ *   yMax coordinates.
+ * @property {number} userUnit - The size of units.
+ * @property {number} scale - The scale of the viewport.
+ * @property {number} rotation - The rotation, in degrees, of the viewport.
+ * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset. The
+ *   default value is `0`.
+ * @property {number} [offsetY] - The vertical, i.e. y-axis, offset. The
+ *   default value is `0`.
+ * @property {boolean} [dontFlip] - If true, the y-axis will not be flipped.
+ *   The default value is `false`.
+ */
+/**
+ * @typedef {Object} PageViewportCloneParameters
+ * @property {number} [scale] - The scale, overriding the one in the cloned
+ *   viewport. The default value is `this.scale`.
+ * @property {number} [rotation] - The rotation, in degrees, overriding the one
+ *   in the cloned viewport. The default value is `this.rotation`.
+ * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset.
+ *   The default value is `this.offsetX`.
+ * @property {number} [offsetY] - The vertical, i.e. y-axis, offset.
+ *   The default value is `this.offsetY`.
+ * @property {boolean} [dontFlip] - If true, the x-axis will not be flipped.
+ *   The default value is `false`.
+ */
+/**
+ * PDF page viewport created based on scale, rotation and offset.
+ */
+export class PageViewport {
+    /**
+     * @param {PageViewportParameters}
+     */
+    constructor({ viewBox, userUnit, scale, rotation, offsetX, offsetY, dontFlip, }: PageViewportParameters);
+    viewBox: number[];
+    userUnit: number;
+    scale: number;
+    rotation: number;
+    offsetX: number;
+    offsetY: number;
+    transform: number[];
+    width: number;
+    height: number;
+    /**
+     * The original, un-scaled, viewport dimensions.
+     * @type {Object}
+     */
+    get rawDims(): Object;
+    /**
+     * Clones viewport, with optional additional properties.
+     * @param {PageViewportCloneParameters} [params]
+     * @returns {PageViewport} Cloned viewport.
+     */
+    clone({ scale, rotation, offsetX, offsetY, dontFlip, }?: PageViewportCloneParameters): PageViewport;
+    /**
+     * Converts PDF point to the viewport coordinates. For examples, useful for
+     * converting PDF location into canvas pixel coordinates.
+     * @param {number} x - The x-coordinate.
+     * @param {number} y - The y-coordinate.
+     * @returns {Array} Array containing `x`- and `y`-coordinates of the
+     *   point in the viewport coordinate space.
+     * @see {@link convertToPdfPoint}
+     * @see {@link convertToViewportRectangle}
+     */
+    convertToViewportPoint(x: number, y: number): any[];
+    /**
+     * Converts PDF rectangle to the viewport coordinates.
+     * @param {Array} rect - The xMin, yMin, xMax and yMax coordinates.
+     * @returns {Array} Array containing corresponding coordinates of the
+     *   rectangle in the viewport coordinate space.
+     * @see {@link convertToViewportPoint}
+     */
+    convertToViewportRectangle(rect: any[]): any[];
+    /**
+     * Converts viewport coordinates to the PDF location. For examples, useful
+     * for converting canvas pixel location into PDF one.
+     * @param {number} x - The x-coordinate.
+     * @param {number} y - The y-coordinate.
+     * @returns {Array} Array containing `x`- and `y`-coordinates of the
+     *   point in the PDF coordinate space.
+     * @see {@link convertToViewportPoint}
+     */
+    convertToPdfPoint(x: number, y: number): any[];
+}
+export class PDFDateString {
+    static "__#2@#regex": any;
+    /**
+     * Convert a PDF date string to a JavaScript `Date` object.
+     *
+     * The PDF date string format is described in section 7.9.4 of the official
+     * PDF 32000-1:2008 specification. However, in the PDF 1.7 reference (sixth
+     * edition) Adobe describes the same format including a trailing apostrophe.
+     * This syntax in incorrect, but Adobe Acrobat creates PDF files that contain
+     * them. We ignore all apostrophes as they are not necessary for date parsing.
+     *
+     * Moreover, Adobe Acrobat doesn't handle changing the date to universal time
+     * and doesn't use the user's time zone (effectively ignoring the HH' and mm'
+     * parts of the date string).
+     *
+     * @param {string} input
+     * @returns {Date|null}
+     */
+    static toDateObject(input: string): Date | null;
+}
+export class PixelsPerInch {
+    static CSS: number;
+    static PDF: number;
+    static PDF_TO_CSS_UNITS: number;
+}
+declare const RenderingCancelledException_base: any;
+export class RenderingCancelledException extends RenderingCancelledException_base {
+    [x: string]: any;
+    constructor(msg: any, extraDelay?: number);
+    extraDelay: number;
+}
+/**
+ * @param {HTMLDivElement} div
+ * @param {PageViewport} viewport
+ * @param {boolean} mustFlip
+ * @param {boolean} mustRotate
+ */
+export function setLayerDimensions(div: HTMLDivElement, viewport: PageViewport, mustFlip?: boolean, mustRotate?: boolean): void;
+export class StatTimer {
+    started: any;
+    times: any[];
+    time(name: any): void;
+    timeEnd(name: any): void;
+    toString(): string;
+}
+export function stopEvent(e: any): void;
+export const SupportedImageMimeTypes: string[];
+export const SVG_NS: "http://www.w3.org/2000/svg";
+export {};

tools/ui/node_modules/pdfjs-dist/types/src/display/draw_layer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Manage the SVGs drawn on top of the page canvas.
+ * It's important to have them directly on top of the canvas because we want to
+ * be able to use mix-blend-mode for some of them.
+ */
+export class DrawLayer {
+    static "__#34@#id": number;
+    static get _svgFactory(): any;
+    static "__#34@#setBox"(element: any, [x, y, width, height]: [any, any, any, any]): void;
+    constructor({ pageIndex }: {
+        pageIndex: any;
+    });
+    pageIndex: any;
+    setParent(parent: any): void;
+    draw(properties: any, isPathUpdatable?: boolean, hasClip?: boolean): {
+        id: number;
+        clipPathId: string;
+    };
+    drawOutline(properties: any, mustRemoveSelfIntersections: any): number;
+    finalizeDraw(id: any, properties: any): void;
+    updateProperties(elementOrId: any, properties: any): void;
+    updateParent(id: any, layer: any): void;
+    remove(id: any): void;
+    destroy(): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/alt_text.d.ts

@@ -0,0 +1,34 @@
+export class AltText {
+    static "__#41@#l10nNewButton": null;
+    static _l10n: null;
+    static initialize(l10n: any): void;
+    constructor(editor: any);
+    render(): Promise<HTMLButtonElement>;
+    finish(): void;
+    isEmpty(): boolean;
+    hasData(): boolean;
+    get guessedText(): null;
+    setGuessedText(guessedText: any): Promise<void>;
+    toggleAltTextBadge(visibility?: boolean): void;
+    serialize(isForCopying: any): {
+        altText: null;
+        decorative: boolean;
+        guessedText: null;
+        textWithDisclaimer: null;
+    };
+    /**
+     * Set the alt text data.
+     */
+    set data({ altText, decorative, guessedText, textWithDisclaimer, cancel, }: {
+        altText: null;
+        decorative: boolean;
+    });
+    get data(): {
+        altText: null;
+        decorative: boolean;
+    };
+    toggle(enabled?: boolean): void;
+    shown(): void;
+    destroy(): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/annotation_editor_layer.d.ts

@@ -0,0 +1,230 @@
+export type AnnotationEditorUIManager = import("./tools.js").AnnotationEditorUIManager;
+export type PageViewport = import("../display_utils.js").PageViewport;
+export type TextAccessibilityManager = import("../../../web/text_accessibility.js").TextAccessibilityManager;
+export type IL10n = import("../../../web/interfaces").IL10n;
+export type AnnotationLayer = import("../annotation_layer.js").AnnotationLayer;
+export type DrawLayer = import("../draw_layer.js").DrawLayer;
+export type StructTreeLayerBuilder = any;
+export type AnnotationEditorLayerOptions = {
+    mode: Object;
+    div: HTMLDivElement;
+    structTreeLayer: StructTreeLayerBuilder;
+    uiManager: AnnotationEditorUIManager;
+    enabled: boolean;
+    accessibilityManager?: import("../../../web/text_accessibility.js").TextAccessibilityManager | undefined;
+    pageIndex: number;
+    l10n: IL10n;
+    annotationLayer?: import("../annotation_layer.js").AnnotationLayer | undefined;
+    textLayer?: HTMLDivElement | undefined;
+    drawLayer: DrawLayer;
+    viewport: PageViewport;
+};
+export type RenderEditorLayerOptions = {
+    viewport: PageViewport;
+};
+/**
+ * @typedef {Object} AnnotationEditorLayerOptions
+ * @property {Object} mode
+ * @property {HTMLDivElement} div
+ * @property {StructTreeLayerBuilder} structTreeLayer
+ * @property {AnnotationEditorUIManager} uiManager
+ * @property {boolean} enabled
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ * @property {number} pageIndex
+ * @property {IL10n} l10n
+ * @property {AnnotationLayer} [annotationLayer]
+ * @property {HTMLDivElement} [textLayer]
+ * @property {DrawLayer} drawLayer
+ * @property {PageViewport} viewport
+ */
+/**
+ * @typedef {Object} RenderEditorLayerOptions
+ * @property {PageViewport} viewport
+ */
+/**
+ * Manage all the different editors on a page.
+ */
+export class AnnotationEditorLayer {
+    static _initialized: boolean;
+    static "__#35@#editorTypes": Map<number, typeof FreeTextEditor | typeof HighlightEditor | typeof InkEditor | typeof SignatureEditor | typeof StampEditor>;
+    /**
+     * @param {AnnotationEditorLayerOptions} options
+     */
+    constructor({ uiManager, pageIndex, div, structTreeLayer, accessibilityManager, annotationLayer, drawLayer, textLayer, viewport, l10n, }: AnnotationEditorLayerOptions);
+    pageIndex: number;
+    div: HTMLDivElement;
+    viewport: import("../display_utils.js").PageViewport;
+    drawLayer: import("../draw_layer.js").DrawLayer;
+    _structTree: any;
+    get isEmpty(): boolean;
+    get isInvisible(): boolean;
+    /**
+     * Update the toolbar if it's required to reflect the tool currently used.
+     * @param {Object} options
+     */
+    updateToolbar(options: Object): void;
+    /**
+     * The mode has changed: it must be updated.
+     * @param {number} mode
+     */
+    updateMode(mode?: number): void;
+    hasTextLayer(textLayer: any): boolean;
+    /**
+     * Set the editing state.
+     * @param {boolean} isEditing
+     */
+    setEditingState(isEditing: boolean): void;
+    /**
+     * Add some commands into the CommandManager (undo/redo stuff).
+     * @param {Object} params
+     */
+    addCommands(params: Object): void;
+    cleanUndoStack(type: any): void;
+    toggleDrawing(enabled?: boolean): void;
+    togglePointerEvents(enabled?: boolean): void;
+    toggleAnnotationLayerPointerEvents(enabled?: boolean): void;
+    /**
+     * Enable pointer events on the main div in order to enable
+     * editor creation.
+     */
+    enable(): Promise<void>;
+    /**
+     * Disable editor creation.
+     */
+    disable(): void;
+    getEditableAnnotation(id: any): any;
+    /**
+     * Set the current editor.
+     * @param {AnnotationEditor} editor
+     */
+    setActiveEditor(editor: AnnotationEditor): void;
+    enableTextSelection(): void;
+    disableTextSelection(): void;
+    enableClick(): void;
+    disableClick(): void;
+    attach(editor: any): void;
+    detach(editor: any): void;
+    /**
+     * Remove an editor.
+     * @param {AnnotationEditor} editor
+     */
+    remove(editor: AnnotationEditor): void;
+    /**
+     * An editor can have a different parent, for example after having
+     * being dragged and dropped from a page to another.
+     * @param {AnnotationEditor} editor
+     */
+    changeParent(editor: AnnotationEditor): void;
+    /**
+     * Add a new editor in the current view.
+     * @param {AnnotationEditor} editor
+     */
+    add(editor: AnnotationEditor): void;
+    moveEditorInDOM(editor: any): void;
+    /**
+     * Add or rebuild depending if it has been removed or not.
+     * @param {AnnotationEditor} editor
+     */
+    addOrRebuild(editor: AnnotationEditor): void;
+    /**
+     * Add a new editor and make this addition undoable.
+     * @param {AnnotationEditor} editor
+     */
+    addUndoableEditor(editor: AnnotationEditor): void;
+    /**
+     * Get an id for an editor.
+     * @returns {string}
+     */
+    getNextId(): string;
+    combinedSignal(ac: any): AbortSignal;
+    canCreateNewEmptyEditor(): boolean | undefined;
+    /**
+     * Paste some content into a new editor.
+     * @param {Object} options
+     * @param {Object} params
+     */
+    pasteEditor(options: Object, params: Object): Promise<void>;
+    /**
+     * Create a new editor
+     * @param {Object} data
+     * @returns {AnnotationEditor | null}
+     */
+    deserialize(data: Object): AnnotationEditor | null;
+    /**
+     * Create and add a new editor.
+     * @param {PointerEvent} event
+     * @param {boolean} isCentered
+     * @param [Object] data
+     * @returns {AnnotationEditor}
+     */
+    createAndAddNewEditor(event: PointerEvent, isCentered: boolean, data?: {}): AnnotationEditor;
+    /**
+     * Create and add a new editor.
+     */
+    addNewEditor(data?: {}): void;
+    /**
+     * Set the last selected editor.
+     * @param {AnnotationEditor} editor
+     */
+    setSelected(editor: AnnotationEditor): void;
+    /**
+     * Add or remove an editor the current selection.
+     * @param {AnnotationEditor} editor
+     */
+    toggleSelected(editor: AnnotationEditor): void;
+    /**
+     * Unselect an editor.
+     * @param {AnnotationEditor} editor
+     */
+    unselect(editor: AnnotationEditor): void;
+    /**
+     * Pointerup callback.
+     * @param {PointerEvent} event
+     */
+    pointerup(event: PointerEvent): void;
+    /**
+     * Pointerdown callback.
+     * @param {PointerEvent} event
+     */
+    pointerdown(event: PointerEvent): void;
+    startDrawingSession(event: any): void;
+    pause(on: any): void;
+    endDrawingSession(isAborted?: boolean): any;
+    /**
+     *
+     * @param {AnnotationEditor} editor
+     * @param {number} x
+     * @param {number} y
+     * @returns
+     */
+    findNewParent(editor: AnnotationEditor, x: number, y: number): boolean;
+    commitOrRemove(): boolean;
+    onScaleChanging(): void;
+    /**
+     * Destroy the main editor.
+     */
+    destroy(): void;
+    /**
+     * Render the main editor.
+     * @param {RenderEditorLayerOptions} parameters
+     */
+    render({ viewport }: RenderEditorLayerOptions): void;
+    /**
+     * Update the main editor.
+     * @param {RenderEditorLayerOptions} parameters
+     */
+    update({ viewport }: RenderEditorLayerOptions): void;
+    /**
+     * Get page dimensions.
+     * @returns {Object} dimensions.
+     */
+    get pageDimensions(): Object;
+    get scale(): number;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";
+import { FreeTextEditor } from "./freetext.js";
+import { HighlightEditor } from "./highlight.js";
+import { InkEditor } from "./ink.js";
+import { SignatureEditor } from "./signature.js";
+import { StampEditor } from "./stamp.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/color_picker.d.ts

@@ -0,0 +1,39 @@
+/**
+ * BasicColorPicker class provides a simple color picker.
+ * It displays an input element (with type="color") that allows the user
+ * to select a color for the annotation.
+ */
+export class BasicColorPicker {
+    static "__#6@#l10nColor": null;
+    constructor(editor: any);
+    renderButton(): HTMLInputElement;
+    update(value: any): void;
+    destroy(): void;
+    hideDropdown(): void;
+    #private;
+}
+/**
+ * ColorPicker class provides a color picker for the annotation editor.
+ * It displays a dropdown with some predefined colors and allows the user
+ * to select a color for the annotation.
+ */
+export class ColorPicker {
+    static "__#5@#l10nColor": null;
+    static get _keyboardManager(): any;
+    constructor({ editor, uiManager }: {
+        editor?: null | undefined;
+        uiManager?: null | undefined;
+    });
+    renderButton(): HTMLButtonElement;
+    renderMainDropdown(): HTMLDivElement;
+    _colorSelectFromKeyboard(event: any): void;
+    _moveToNext(event: any): void;
+    _moveToPrevious(event: any): void;
+    _moveToBeginning(event: any): void;
+    _moveToEnd(event: any): void;
+    hideDropdown(): void;
+    _hideDropdownFromKeyboard(): void;
+    updateColor(color: any): void;
+    destroy(): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/comment.d.ts

@@ -0,0 +1,32 @@
+export class Comment {
+    constructor(editor: any);
+    toolbar: any;
+    render(): HTMLButtonElement | null;
+    edit(): void;
+    finish(): void;
+    isDeleted(): boolean;
+    hasBeenEdited(): boolean;
+    serialize(): {
+        text: null;
+        date: null;
+        deleted: boolean;
+    };
+    /**
+     * Set the comment data.
+     */
+    set data(text: {
+        text: null;
+        date: null;
+        deleted: boolean;
+    });
+    get data(): {
+        text: null;
+        date: null;
+        deleted: boolean;
+    };
+    setInitialText(text: any): void;
+    toggle(enabled?: boolean): void;
+    shown(): void;
+    destroy(): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/draw.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Basic draw editor.
+ */
+export class DrawingEditor extends AnnotationEditor {
+    static _currentDrawId: number;
+    static _currentParent: null;
+    static "__#27@#currentDraw": null;
+    static "__#27@#currentDrawingAC": null;
+    static "__#27@#currentDrawingOptions": null;
+    static "__#27@#currentPointerId": number;
+    static "__#27@#currentPointerType": null;
+    static "__#27@#currentPointerIds": null;
+    static "__#27@#currentMoveTimestamp": number;
+    static _INNER_MARGIN: number;
+    static _mergeSVGProperties(p1: any, p2: any): any;
+    /**
+     * @param {Object} options
+     * @return {DrawingOptions} the default options to use for a new editor.
+     */
+    static getDefaultDrawingOptions(_options: any): DrawingOptions;
+    /**
+     * @return {Map<AnnotationEditorParamsType, string>} a map between the
+     *   parameter types and the name of the options.
+     */
+    static get typesMap(): Map<{
+        RESIZE: number;
+        CREATE: number;
+        FREETEXT_SIZE: number;
+        FREETEXT_COLOR: number;
+        FREETEXT_OPACITY: number;
+        INK_COLOR: number;
+        INK_THICKNESS: number;
+        INK_OPACITY: number;
+        HIGHLIGHT_COLOR: number;
+        HIGHLIGHT_THICKNESS: number;
+        HIGHLIGHT_FREE: number;
+        HIGHLIGHT_SHOW_ALL: number;
+        DRAW_STEP: number;
+    }, string>;
+    /**
+     * @returns {boolean} `true` if several drawings can be added to the
+     * annotation.
+     */
+    static get supportMultipleDrawings(): boolean;
+    /** @inheritdoc */
+    static updateDefaultParams(type: any, value: any): void;
+    /** @inheritdoc */
+    static get defaultPropertiesToUpdate(): any[][];
+    static onScaleChangingWhenDrawing(): void;
+    /**
+     * Create a new drawer instance.
+     * @param {number} x - The x coordinate of the event.
+     * @param {number} y - The y coordinate of the event.
+     * @param {number} parentWidth - The parent width.
+     * @param {number} parentHeight - The parent height.
+     * @param {number} rotation - The parent rotation.
+     */
+    static createDrawerInstance(_x: any, _y: any, _parentWidth: any, _parentHeight: any, _rotation: any): void;
+    static startDrawing(parent: any, uiManager: any, _isLTR: any, event: any): void;
+    static _drawMove(event: any): void;
+    static _cleanup(all: any): void;
+    static _endDraw(event: any): void;
+    static endDrawing(isAborted: any): any;
+    /**
+     * Deserialize the drawing outlines.
+     * @param {number} pageX - The x coordinate of the page.
+     * @param {number} pageY - The y coordinate of the page.
+     * @param {number} pageWidth - The width of the page.
+     * @param {number} pageHeight - The height of the page.
+     * @param {number} innerWidth - The inner width.
+     * @param {Object} data - The data to deserialize.
+     * @returns {Object} The deserialized outlines.
+     */
+    static deserializeDraw(_pageX: any, _pageY: any, _pageWidth: any, _pageHeight: any, _innerWidth: any, _data: any): Object;
+    /** @inheritdoc */
+    static deserialize(data: any, parent: any, uiManager: any): Promise<AnnotationEditor | null>;
+    constructor(params: any);
+    _colorPicker: null;
+    _drawId: null;
+    _addOutlines(params: any): void;
+    /** @inheritdoc */
+    updateParams(type: any, value: any): void;
+    /** @inheritdoc */
+    get propertiesToUpdate(): any[][];
+    /**
+     * Update a property and make this action undoable.
+     * @param {string} color
+     */
+    _updateProperty(type: any, name: any, value: any): void;
+    /** @inheritdoc */
+    _onTranslating(_x: any, _y: any): void;
+    /** @inheritdoc */
+    _onTranslated(): void;
+    /** @inheritdoc */
+    onceAdded(focus: any): void;
+    /** @inheritdoc */
+    rotate(): void;
+    onScaleChanging(): void;
+    /**
+     * Create the drawing options.
+     * @param {Object} _data
+     */
+    createDrawingOptions(_data: Object): void;
+    serializeDraw(isForCopying: any): any;
+    /** @inheritdoc */
+    renderAnnotationElement(annotation: any): null;
+    #private;
+}
+export class DrawingOptions {
+    updateProperty(name: any, value: any): void;
+    updateProperties(properties: any): void;
+    updateSVGProperty(name: any, value: any): void;
+    toSVGProperties(): {
+        root: any;
+    };
+    reset(): void;
+    updateAll(options?: this): void;
+    clone(): void;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/drawers/contour.d.ts

@@ -0,0 +1,3 @@
+export class ContourDrawOutline extends InkDrawOutline {
+}
+import { InkDrawOutline } from "./inkdraw.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/drawers/freedraw.d.ts

@@ -0,0 +1,31 @@
+export class FreeDrawOutline extends Outline {
+    constructor(outline: any, points: any, box: any, scaleFactor: any, innerMargin: any, isLTR: any);
+    lastPoint: number[];
+    serialize([blX, blY, trX, trY]: [any, any, any, any], rotation: any): {
+        outline: any[];
+        points: any[][];
+    };
+    get box(): Float32Array<ArrayBuffer>;
+    newOutliner(point: any, box: any, scaleFactor: any, thickness: any, isLTR: any, innerMargin?: number): FreeDrawOutliner;
+    getNewOutline(thickness: any, innerMargin: any): FreeDrawOutline;
+    #private;
+}
+export class FreeDrawOutliner {
+    static "__#21@#MIN_DIST": number;
+    static "__#21@#MIN_DIFF": number;
+    static "__#21@#MIN": number;
+    constructor({ x, y }: {
+        x: any;
+        y: any;
+    }, box: any, scaleFactor: any, thickness: any, isLTR: any, innerMargin?: number);
+    isEmpty(): boolean;
+    add({ x, y }: {
+        x: any;
+        y: any;
+    }): boolean;
+    toSVGPath(): string;
+    newFreeDrawOutline(outline: any, points: any, box: any, scaleFactor: any, innerMargin: any, isLTR: any): FreeDrawOutline;
+    getOutlines(): FreeDrawOutline;
+    #private;
+}
+import { Outline } from "./outline.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/drawers/highlight.d.ts

@@ -0,0 +1,36 @@
+export class FreeHighlightOutliner extends FreeDrawOutliner {
+}
+export class HighlightOutliner {
+    /**
+     * Construct an outliner.
+     * @param {Array<Object>} boxes - An array of axis-aligned rectangles.
+     * @param {number} borderWidth - The width of the border of the boxes, it
+     *   allows to make the boxes bigger (or smaller).
+     * @param {number} innerMargin - The margin between the boxes and the
+     *   outlines. It's important to not have a null innerMargin when we want to
+     *   draw the outline else the stroked outline could be clipped because of its
+     *   width.
+     * @param {boolean} isLTR - true if we're in LTR mode. It's used to determine
+     *   the last point of the boxes.
+     */
+    constructor(boxes: Array<Object>, borderWidth?: number, innerMargin?: number, isLTR?: boolean);
+    getOutlines(): HighlightOutline;
+    #private;
+}
+import { FreeDrawOutliner } from "./freedraw.js";
+declare class HighlightOutline extends Outline {
+    constructor(outlines: any, box: any, lastPoint: any);
+    lastPoint: any;
+    /**
+     * Serialize the outlines into the PDF page coordinate system.
+     * @param {Array<number>} _bbox - the bounding box of the annotation.
+     * @param {number} _rotation - the rotation of the annotation.
+     * @returns {Array<Array<number>>}
+     */
+    serialize([blX, blY, trX, trY]: Array<number>, _rotation: number): Array<Array<number>>;
+    get box(): any;
+    get classNamesForOutlining(): string[];
+    #private;
+}
+import { Outline } from "./outline.js";
+export {};

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/drawers/inkdraw.d.ts

@@ -0,0 +1,129 @@
+export class InkDrawOutline extends Outline {
+    static deserialize(pageX: any, pageY: any, pageWidth: any, pageHeight: any, innerMargin: any, { paths: { lines, points }, rotation, thickness }: {
+        paths: {
+            lines: any;
+            points: any;
+        };
+        rotation: any;
+        thickness: any;
+    }): any;
+    build(lines: any, parentWidth: any, parentHeight: any, parentScale: any, rotation: any, thickness: any, innerMargin: any): void;
+    get thickness(): any;
+    setLastElement(element: any): {
+        path: {
+            d: string;
+        };
+    };
+    removeLastElement(): {
+        path: {
+            d: string;
+        };
+    };
+    serialize([pageX, pageY, pageWidth, pageHeight]: [any, any, any, any], isForCopying: any): {
+        lines: any[];
+        points: any[];
+        rect: any[];
+    };
+    get box(): any;
+    updateProperty(name: any, value: any): any;
+    updateParentDimensions([width, height]: [any, any], scale: any): any;
+    updateRotation(rotation: any): {
+        path: {
+            transform: string;
+        };
+    };
+    get viewBox(): any;
+    get defaultProperties(): {
+        root: {
+            viewBox: any;
+        };
+        path: {
+            "transform-origin": string;
+        };
+    };
+    get rotationTransform(): string;
+    getPathResizingSVGProperties([newX, newY, newWidth, newHeight]: [any, any, any, any]): {
+        path: {
+            "transform-origin": string;
+            transform: string;
+        };
+    };
+    getPathResizedSVGProperties([newX, newY, newWidth, newHeight]: [any, any, any, any]): {
+        root: {
+            viewBox: any;
+        };
+        path: {
+            "transform-origin": string;
+            transform: string | null;
+            d: string;
+        };
+    };
+    getPathTranslatedSVGProperties([newX, newY]: [any, any], parentDimensions: any): {
+        root: {
+            viewBox: any;
+        };
+        path: {
+            d: string;
+            "transform-origin": string;
+        };
+    };
+    get defaultSVGProperties(): {
+        root: {
+            viewBox: any;
+        };
+        rootClass: {
+            draw: boolean;
+        };
+        path: {
+            d: string;
+            "transform-origin": string;
+            transform: string | null;
+        };
+        bbox: any;
+    };
+    #private;
+}
+export class InkDrawOutliner {
+    constructor(x: any, y: any, parentWidth: any, parentHeight: any, rotation: any, thickness: any);
+    updateProperty(name: any, value: any): void;
+    isEmpty(): boolean;
+    isCancellable(): boolean;
+    add(x: any, y: any): {
+        path: {
+            d: string;
+        };
+    } | null;
+    end(x: any, y: any): {
+        path: {
+            d: string;
+        };
+    } | null;
+    startNew(x: any, y: any, parentWidth: any, parentHeight: any, rotation: any): null;
+    getLastElement(): {
+        line: any[];
+        points: any[];
+    } | undefined;
+    setLastElement(element: any): {
+        path: {
+            d: string;
+        };
+    };
+    removeLastElement(): {
+        path: {
+            d: string;
+        };
+    };
+    toSVGPath(): string;
+    getOutlines(parentWidth: any, parentHeight: any, scale: any, innerMargin: any): InkDrawOutline;
+    get defaultSVGProperties(): {
+        root: {
+            viewBox: string;
+        };
+        rootClass: {
+            draw: boolean;
+        };
+        bbox: number[];
+    };
+    #private;
+}
+import { Outline } from "./outline.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/drawers/outline.d.ts

@@ -0,0 +1,19 @@
+export class Outline {
+    static PRECISION: number;
+    static _rescale(src: any, tx: any, ty: any, sx: any, sy: any, dest: any): any;
+    static _rescaleAndSwap(src: any, tx: any, ty: any, sx: any, sy: any, dest: any): any;
+    static _translate(src: any, tx: any, ty: any, dest: any): any;
+    static svgRound(x: any): number;
+    static _normalizePoint(x: any, y: any, parentWidth: any, parentHeight: any, rotation: any): number[];
+    static _normalizePagePoint(x: any, y: any, rotation: any): any[];
+    static createBezierPoints(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): number[];
+    /**
+     * @returns {string} The SVG path of the outline.
+     */
+    toSVGPath(): string;
+    /**
+     * @type {Object|null} The bounding box of the outline.
+     */
+    get box(): Object | null;
+    serialize(_bbox: any, _rotation: any): void;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/drawers/signaturedraw.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Basic text editor in order to create a Signature annotation.
+ */
+export class SignatureExtractor {
+    static "__#31@#PARAMETERS": {
+        maxDim: number;
+        sigmaSFactor: number;
+        sigmaR: number;
+        kernelSize: number;
+    };
+    static "__#31@#neighborIndexToId"(i0: any, j0: any, i: any, j: any): any;
+    static "__#31@#neighborIdToIndex": Int32Array<ArrayBuffer>;
+    static "__#31@#clockwiseNonZero"(buf: any, width: any, i0: any, j0: any, i: any, j: any, offset: any): number;
+    static "__#31@#counterClockwiseNonZero"(buf: any, width: any, i0: any, j0: any, i: any, j: any, offset: any): number;
+    static "__#31@#findContours"(buf: any, width: any, height: any, threshold: any): {
+        isHole: boolean;
+        points: number[];
+        id: number;
+        parent: number;
+    }[];
+    static "__#31@#douglasPeuckerHelper"(points: any, start: any, end: any, output: any): void;
+    static "__#31@#douglasPeucker"(points: any): any[] | null;
+    static "__#31@#bilateralFilter"(buf: any, width: any, height: any, sigmaS: any, sigmaR: any, kernelSize: any): (Uint32Array<ArrayBuffer> | Uint8Array<any>)[];
+    static "__#31@#getHistogram"(buf: any): Uint32Array<ArrayBuffer>;
+    static "__#31@#toUint8"(buf: any): Uint8ClampedArray<ArrayBuffer>;
+    static "__#31@#guessThreshold"(histogram: any): number;
+    static "__#31@#getGrayPixels"(bitmap: any): any[];
+    static extractContoursFromText(text: any, { fontFamily, fontStyle, fontWeight }: {
+        fontFamily: any;
+        fontStyle: any;
+        fontWeight: any;
+    }, pageWidth: any, pageHeight: any, rotation: any, innerMargin: any): {
+        outline: InkDrawOutline;
+        newCurves: any[];
+        areContours: any;
+        thickness: any;
+        width: any;
+        height: any;
+    } | null;
+    static process(bitmap: any, pageWidth: any, pageHeight: any, rotation: any, innerMargin: any): {
+        outline: InkDrawOutline;
+        newCurves: any[];
+        areContours: any;
+        thickness: any;
+        width: any;
+        height: any;
+    } | null;
+    static processDrawnLines({ lines, pageWidth, pageHeight, rotation, innerMargin, mustSmooth, areContours, }: {
+        lines: any;
+        pageWidth: any;
+        pageHeight: any;
+        rotation: any;
+        innerMargin: any;
+        mustSmooth: any;
+        areContours: any;
+    }): {
+        outline: InkDrawOutline;
+        newCurves: any[];
+        areContours: any;
+        thickness: any;
+        width: any;
+        height: any;
+    } | null;
+    static compressSignature({ outlines, areContours, thickness, width, height, }: {
+        outlines: any;
+        areContours: any;
+        thickness: any;
+        width: any;
+        height: any;
+    }): Promise<any>;
+    static decompressSignature(signatureData: any): Promise<{
+        areContours: boolean;
+        thickness: number;
+        outlines: Float32Array<ArrayBuffer>[];
+        width: number;
+        height: number;
+    } | null>;
+}
+import { InkDrawOutline } from "./inkdraw.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/editor.d.ts

@@ -0,0 +1,517 @@
+export type AnnotationEditorLayer = import("./annotation_editor_layer.js").AnnotationEditorLayer;
+export type AnnotationEditorParameters = {
+    /**
+     * - the global manager
+     */
+    uiManager: AnnotationEditorUIManager;
+    /**
+     * - the layer containing this editor
+     */
+    parent: AnnotationEditorLayer;
+    /**
+     * - editor id
+     */
+    id: string;
+    /**
+     * - x-coordinate
+     */
+    x: number;
+    /**
+     * - y-coordinate
+     */
+    y: number;
+};
+/**
+ * @typedef {Object} AnnotationEditorParameters
+ * @property {AnnotationEditorUIManager} uiManager - the global manager
+ * @property {AnnotationEditorLayer} parent - the layer containing this editor
+ * @property {string} id - editor id
+ * @property {number} x - x-coordinate
+ * @property {number} y - y-coordinate
+ */
+/**
+ * Base class for editors.
+ */
+export class AnnotationEditor {
+    static _l10n: null;
+    static _l10nResizer: null;
+    static _borderLineWidth: number;
+    static _colorManager: ColorManager;
+    static _zIndex: number;
+    static _telemetryTimeout: number;
+    static get _resizerKeyboardManager(): any;
+    static get isDrawer(): boolean;
+    static get _defaultLineColor(): any;
+    static deleteAnnotationElement(editor: any): void;
+    /**
+     * Initialize the l10n stuff for this type of editor.
+     * @param {Object} l10n
+     */
+    static initialize(l10n: Object, _uiManager: any): void;
+    /**
+     * Update the default parameters for this type of editor.
+     * @param {number} _type
+     * @param {*} _value
+     */
+    static updateDefaultParams(_type: number, _value: any): void;
+    /**
+     * Get the default properties to set in the UI for this type of editor.
+     * @returns {Array}
+     */
+    static get defaultPropertiesToUpdate(): any[];
+    /**
+     * Check if this kind of editor is able to handle the given mime type for
+     * pasting.
+     * @param {string} mime
+     * @returns {boolean}
+     */
+    static isHandlingMimeForPasting(mime: string): boolean;
+    /**
+     * Extract the data from the clipboard item and delegate the creation of the
+     * editor to the parent.
+     * @param {DataTransferItem} item
+     * @param {AnnotationEditorLayer} parent
+     */
+    static paste(item: DataTransferItem, parent: AnnotationEditorLayer): void;
+    static "__#44@#rotatePoint"(x: any, y: any, angle: any): any[];
+    static _round(x: any): number;
+    /**
+     * Deserialize the editor.
+     * The result of the deserialization is a new editor.
+     *
+     * @param {Object} data
+     * @param {AnnotationEditorLayer} parent
+     * @param {AnnotationEditorUIManager} uiManager
+     * @returns {Promise<AnnotationEditor | null>}
+     */
+    static deserialize(data: Object, parent: AnnotationEditorLayer, uiManager: AnnotationEditorUIManager): Promise<AnnotationEditor | null>;
+    static get MIN_SIZE(): number;
+    static canCreateNewEmptyEditor(): boolean;
+    /**
+     * @param {AnnotationEditorParameters} parameters
+     */
+    constructor(parameters: AnnotationEditorParameters);
+    isSelected: boolean;
+    _isCopy: boolean;
+    _editToolbar: null;
+    _initialOptions: any;
+    _initialData: null;
+    _isVisible: boolean;
+    _uiManager: null;
+    _focusEventsAllowed: boolean;
+    parent: import("./annotation_editor_layer.js").AnnotationEditorLayer;
+    id: string;
+    width: any;
+    height: any;
+    pageIndex: number;
+    name: any;
+    div: HTMLDivElement | null;
+    annotationElementId: any;
+    _willKeepAspectRatio: boolean;
+    _structTreeParentId: any;
+    rotation: number;
+    pageRotation: number;
+    pageDimensions: any[];
+    pageTranslation: any[];
+    x: number;
+    y: number;
+    isAttachedToDOM: boolean;
+    deleted: boolean;
+    get editorType(): any;
+    get mode(): any;
+    /**
+     * Get the properties to update in the UI for this editor.
+     * @returns {Array}
+     */
+    get propertiesToUpdate(): any[];
+    set _isDraggable(value: boolean);
+    get _isDraggable(): boolean;
+    /**
+     * @returns {boolean} true if the editor handles the Enter key itself.
+     */
+    get isEnterHandled(): boolean;
+    center(): void;
+    /**
+     * Add some commands into the CommandManager (undo/redo stuff).
+     * @param {Object} params
+     */
+    addCommands(params: Object): void;
+    get currentLayer(): any;
+    /**
+     * This editor will be behind the others.
+     */
+    setInBackground(): void;
+    /**
+     * This editor will be in the foreground.
+     */
+    setInForeground(): void;
+    setParent(parent: any): void;
+    /**
+     * onfocus callback.
+     */
+    focusin(event: any): void;
+    /**
+     * onblur callback.
+     * @param {FocusEvent} event
+     */
+    focusout(event: FocusEvent): void;
+    commitOrRemove(): void;
+    /**
+     * Commit the data contained in this editor.
+     */
+    commit(): void;
+    addToAnnotationStorage(): void;
+    /**
+     * Set the editor position within its parent.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} tx - x-translation in screen coordinates.
+     * @param {number} ty - y-translation in screen coordinates.
+     */
+    setAt(x: number, y: number, tx: number, ty: number): void;
+    _moveAfterPaste(baseX: any, baseY: any): void;
+    /**
+     * Translate the editor position within its parent.
+     * @param {number} x - x-translation in screen coordinates.
+     * @param {number} y - y-translation in screen coordinates.
+     */
+    translate(x: number, y: number): void;
+    /**
+     * Translate the editor position within its page and adjust the scroll
+     * in order to have the editor in the view.
+     * @param {number} x - x-translation in page coordinates.
+     * @param {number} y - y-translation in page coordinates.
+     */
+    translateInPage(x: number, y: number): void;
+    translationDone(): void;
+    drag(tx: any, ty: any): void;
+    /**
+     * Called when the editor is being translated.
+     * @param {number} x - in page coordinates.
+     * @param {number} y - in page coordinates.
+     */
+    _onTranslating(x: number, y: number): void;
+    /**
+     * Called when the editor has been translated.
+     * @param {number} x - in page coordinates.
+     * @param {number} y - in page coordinates.
+     */
+    _onTranslated(x: number, y: number): void;
+    get _hasBeenMoved(): boolean;
+    get _hasBeenResized(): boolean;
+    /**
+     * Get the translation to take into account the editor border.
+     * The CSS engine positions the element by taking the border into account so
+     * we must apply the opposite translation to have the editor in the right
+     * position.
+     * @returns {Array<number>}
+     */
+    getBaseTranslation(): Array<number>;
+    /**
+     * @returns {boolean} true if position must be fixed (i.e. make the x and y
+     * living in the page).
+     */
+    get _mustFixPosition(): boolean;
+    /**
+     * Fix the position of the editor in order to keep it inside its parent page.
+     * @param {number} [rotation] - the rotation of the page.
+     */
+    fixAndSetPosition(rotation?: number): void;
+    /**
+     * Convert a screen translation into a page one.
+     * @param {number} x
+     * @param {number} y
+     */
+    screenToPageTranslation(x: number, y: number): any[];
+    /**
+     * Convert a page translation into a screen one.
+     * @param {number} x
+     * @param {number} y
+     */
+    pageTranslationToScreen(x: number, y: number): any[];
+    get parentScale(): any;
+    get parentRotation(): number;
+    get parentDimensions(): number[];
+    /**
+     * Set the dimensions of this editor.
+     * @param {number} width
+     * @param {number} height
+     */
+    setDims(width: number, height: number): void;
+    fixDims(): void;
+    /**
+     * Get the translation used to position this editor when it's created.
+     * @returns {Array<number>}
+     */
+    getInitialTranslation(): Array<number>;
+    /**
+     * Called when the editor has been resized.
+     */
+    _onResized(): void;
+    /**
+     * Called when the editor is being resized.
+     */
+    _onResizing(): void;
+    /**
+     * Called when the alt text dialog is closed.
+     */
+    altTextFinish(): void;
+    /**
+     * Get the toolbar buttons for this editor.
+     * @returns {Array<Array<string|object|null>>|null}
+     */
+    get toolbarButtons(): Array<Array<string | object | null>> | null;
+    /**
+     * Add a toolbar for this editor.
+     * @returns {Promise<EditorToolbar|null>}
+     */
+    addEditToolbar(): Promise<EditorToolbar | null>;
+    removeEditToolbar(): void;
+    addContainer(container: any): void;
+    getClientDimensions(): DOMRect;
+    /**
+     * Create the alt text for this editor.
+     * @returns {object}
+     */
+    createAltText(): object;
+    /**
+     * Set the alt text data.
+     */
+    set altTextData(data: any);
+    get altTextData(): any;
+    get guessedAltText(): any;
+    setGuessedAltText(text: any): Promise<void>;
+    serializeAltText(isForCopying: any): any;
+    hasAltText(): boolean;
+    hasAltTextData(): any;
+    addCommentButton(): Comment;
+    get commentColor(): null;
+    set comment(text: {
+        text: any;
+        date: any;
+        deleted: any;
+        color: null;
+    });
+    get comment(): {
+        text: any;
+        date: any;
+        deleted: any;
+        color: null;
+    };
+    setCommentData(text: any): void;
+    get hasEditedComment(): any;
+    editComment(): Promise<void>;
+    addComment(serialized: any): void;
+    /**
+     * Render this editor in a div.
+     * @returns {HTMLDivElement | null}
+     */
+    render(): HTMLDivElement | null;
+    /**
+     * Onpointerdown callback.
+     * @param {PointerEvent} event
+     */
+    pointerdown(event: PointerEvent): void;
+    _onStartDragging(): void;
+    _onStopDragging(): void;
+    moveInDOM(): void;
+    _setParentAndPosition(parent: any, x: any, y: any): void;
+    /**
+     * Convert the current rect into a page one.
+     * @param {number} tx - x-translation in screen coordinates.
+     * @param {number} ty - y-translation in screen coordinates.
+     * @param {number} [rotation] - the rotation of the page.
+     */
+    getRect(tx: number, ty: number, rotation?: number): any[];
+    getRectInCurrentCoords(rect: any, pageHeight: any): any[];
+    /**
+     * Executed once this editor has been rendered.
+     * @param {boolean} focus - true if the editor should be focused.
+     */
+    onceAdded(focus: boolean): void;
+    /**
+     * Check if the editor contains something.
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * Enable edit mode.
+     * @returns {boolean} - true if the edit mode has been enabled.
+     */
+    enableEditMode(): boolean;
+    /**
+     * Disable edit mode.
+     * @returns {boolean} - true if the edit mode has been disabled.
+     */
+    disableEditMode(): boolean;
+    /**
+     * Check if the editor is edited.
+     * @returns {boolean}
+     */
+    isInEditMode(): boolean;
+    /**
+     * If it returns true, then this editor handles the keyboard
+     * events itself.
+     * @returns {boolean}
+     */
+    shouldGetKeyboardEvents(): boolean;
+    /**
+     * Check if this editor needs to be rebuilt or not.
+     * @returns {boolean}
+     */
+    needsToBeRebuilt(): boolean;
+    get isOnScreen(): boolean;
+    /**
+     * Rebuild the editor in case it has been removed on undo.
+     *
+     * To implement in subclasses.
+     */
+    rebuild(): void;
+    /**
+     * Rotate the editor when the page is rotated.
+     * @param {number} angle
+     */
+    rotate(_angle: any): void;
+    /**
+     * Resize the editor when the page is resized.
+     */
+    resize(): void;
+    /**
+     * Serialize the editor when it has been deleted.
+     * @returns {Object}
+     */
+    serializeDeleted(): Object;
+    /**
+     * Serialize the editor.
+     * The result of the serialization will be used to construct a
+     * new annotation to add to the pdf document.
+     *
+     * To implement in subclasses.
+     * @param {boolean} [isForCopying]
+     * @param {Object | null} [context]
+     * @returns {Object | null}
+     */
+    serialize(isForCopying?: boolean, context?: Object | null): Object | null;
+    /**
+     * Check if an existing annotation associated with this editor has been
+     * modified.
+     * @returns {boolean}
+     */
+    get hasBeenModified(): boolean;
+    /**
+     * Remove this editor.
+     * It's used on ctrl+backspace action.
+     */
+    remove(): void;
+    /**
+     * @returns {boolean} true if this editor can be resized.
+     */
+    get isResizable(): boolean;
+    /**
+     * Add the resizers to this editor.
+     */
+    makeResizable(): void;
+    get toolbarPosition(): null;
+    /**
+     * onkeydown callback.
+     * @param {KeyboardEvent} event
+     */
+    keydown(event: KeyboardEvent): void;
+    _resizeWithKeyboard(x: any, y: any): void;
+    _stopResizingWithKeyboard(): void;
+    /**
+     * Select this editor.
+     */
+    select(): void;
+    /**
+     * Unselect this editor.
+     */
+    unselect(): void;
+    /**
+     * Update some parameters which have been changed through the UI.
+     * @param {number} type
+     * @param {*} value
+     */
+    updateParams(type: number, value: any): void;
+    /**
+     * When the user disables the editing mode some editors can change some of
+     * their properties.
+     */
+    disableEditing(): void;
+    /**
+     * When the user enables the editing mode some editors can change some of
+     * their properties.
+     */
+    enableEditing(): void;
+    /**
+     * Check if the content of this editor can be changed.
+     * For example, a FreeText editor can be changed (the user can change the
+     * text), but a Stamp editor cannot.
+     * @returns {boolean}
+     */
+    get canChangeContent(): boolean;
+    /**
+     * The editor is about to be edited.
+     */
+    enterInEditMode(): void;
+    /**
+     * ondblclick callback.
+     * @param {MouseEvent} event
+     */
+    dblclick(event: MouseEvent): void;
+    /**
+     * @returns {HTMLElement | null} the element requiring an alt text.
+     */
+    getElementForAltText(): HTMLElement | null;
+    /**
+     * Get the div which really contains the displayed content.
+     * @returns {HTMLDivElement | undefined}
+     */
+    get contentDiv(): HTMLDivElement | undefined;
+    /**
+     * When set to true, it means that this editor is currently edited.
+     * @param {boolean} value
+     */
+    set isEditing(value: boolean);
+    /**
+     * If true then the editor is currently edited.
+     * @type {boolean}
+     */
+    get isEditing(): boolean;
+    /**
+     * Set the aspect ratio to use when resizing.
+     * @param {number} width
+     * @param {number} height
+     */
+    setAspectRatio(width: number, height: number): void;
+    /**
+     * Get the data to report to the telemetry when the editor is added.
+     * @returns {Object}
+     */
+    get telemetryInitialData(): Object;
+    /**
+     * The telemetry data to use when saving/printing.
+     * @returns {Object|null}
+     */
+    get telemetryFinalData(): Object | null;
+    _reportTelemetry(data: any, mustWait?: boolean): void;
+    /**
+     * Show or hide this editor.
+     * @param {boolean|undefined} visible
+     */
+    show(visible?: boolean | undefined): void;
+    enable(): void;
+    disable(): void;
+    /**
+     * Render an annotation in the annotation layer.
+     * @param {Object} annotation
+     * @returns {HTMLElement|null}
+     */
+    renderAnnotationElement(annotation: Object): HTMLElement | null;
+    resetAnnotationElement(annotation: any): void;
+    #private;
+}
+import { AnnotationEditorUIManager } from "./tools.js";
+import { EditorToolbar } from "./toolbar.js";
+import { Comment } from "./comment.js";
+import { ColorManager } from "./tools.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/freetext.d.ts

@@ -0,0 +1,61 @@
+export type AnnotationEditorLayer = import("./annotation_editor_layer.js").AnnotationEditorLayer;
+/**
+ * Basic text editor in order to create a FreeTex annotation.
+ */
+export class FreeTextEditor extends AnnotationEditor {
+    static _freeTextDefaultContent: string;
+    static _internalPadding: number;
+    static _defaultColor: null;
+    static _defaultFontSize: number;
+    static get _keyboardManager(): any;
+    static _type: string;
+    static _editorType: number;
+    /** @inheritdoc */
+    static initialize(l10n: any, uiManager: any): void;
+    /** @inheritdoc */
+    static updateDefaultParams(type: any, value: any): void;
+    /** @inheritdoc */
+    static get defaultPropertiesToUpdate(): any[][];
+    static "__#20@#getNodeContent"(node: any): any;
+    static "__#20@#deserializeContent"(content: any): any;
+    /** @inheritdoc */
+    static deserialize(data: any, parent: any, uiManager: any): Promise<AnnotationEditor | null>;
+    constructor(params: any);
+    _colorPicker: null;
+    /** @inheritdoc */
+    updateParams(type: any, value: any): void;
+    /** @inheritdoc */
+    get propertiesToUpdate(): any[][];
+    /** @inheritdoc */
+    get toolbarButtons(): (string | null)[][];
+    get colorType(): number;
+    get colorValue(): any;
+    /**
+     * Helper to translate the editor with the keyboard when it's empty.
+     * @param {number} x in page units.
+     * @param {number} y in page units.
+     */
+    _translateEmpty(x: number, y: number): void;
+    /** @inheritdoc */
+    onceAdded(focus: any): void;
+    /**
+     * Commit the content we have in this editor.
+     * @returns {undefined}
+     */
+    commit(): undefined;
+    /** @inheritdoc */
+    keydown(event: any): void;
+    editorDivKeydown(event: any): void;
+    editorDivFocus(event: any): void;
+    editorDivBlur(event: any): void;
+    editorDivInput(event: any): void;
+    editorDiv: HTMLDivElement | undefined;
+    overlayDiv: HTMLDivElement | undefined;
+    editorDivPaste(event: any): void;
+    /** @inheritdoc */
+    serialize(isForCopying?: boolean): Object | null;
+    /** @inheritdoc */
+    renderAnnotationElement(annotation: any): HTMLElement | null;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/highlight.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Basic draw editor in order to generate an Highlight annotation.
+ */
+export class HighlightEditor extends AnnotationEditor {
+    static _defaultColor: null;
+    static _defaultOpacity: number;
+    static _defaultThickness: number;
+    static _type: string;
+    static _editorType: number;
+    static _freeHighlightId: number;
+    static _freeHighlight: null;
+    static _freeHighlightClipId: string;
+    static get _keyboardManager(): any;
+    static computeTelemetryFinalData(data: any): {
+        numberOfColors: any;
+    };
+    /** @inheritdoc */
+    static initialize(l10n: any, uiManager: any): void;
+    /** @inheritdoc */
+    static updateDefaultParams(type: any, value: any): void;
+    static get defaultPropertiesToUpdate(): (number | null)[][];
+    static "__#25@#rotateBbox"([x, y, width, height]: [any, any, any, any], angle: any): any[];
+    static startHighlighting(parent: any, isLTR: any, { target: textLayer, x, y }: {
+        target: any;
+        x: any;
+        y: any;
+    }): void;
+    static "__#25@#highlightMove"(parent: any, event: any): void;
+    static "__#25@#endHighlight"(parent: any, event: any): void;
+    /** @inheritdoc */
+    static deserialize(data: any, parent: any, uiManager: any): Promise<AnnotationEditor | null>;
+    constructor(params: any);
+    color: any;
+    defaultL10nId: string;
+    /** @inheritdoc */
+    get telemetryInitialData(): {
+        action: string;
+        type: string;
+        color: any;
+        thickness: any;
+        methodOfCreation: string;
+    };
+    /** @inheritdoc */
+    get telemetryFinalData(): {
+        type: string;
+        color: any;
+    };
+    get commentColor(): any;
+    /** @inheritdoc */
+    translateInPage(x: any, y: any): void;
+    /** @inheritdoc */
+    updateParams(type: any, value: any): void;
+    /** @inheritdoc */
+    get propertiesToUpdate(): any[][];
+    /** @inheritdoc */
+    get toolbarButtons(): any;
+    /** @inheritdoc */
+    fixAndSetPosition(): void;
+    /** @inheritdoc */
+    getRect(tx: any, ty: any): any[];
+    /** @inheritdoc */
+    onceAdded(focus: any): void;
+    /** @inheritdoc */
+    rotate(angle: any): void;
+    pointerover(): void;
+    pointerleave(): void;
+    _moveCaret(direction: any): void;
+    /** @inheritdoc */
+    serialize(isForCopying?: boolean): Object | null;
+    /** @inheritdoc */
+    renderAnnotationElement(annotation: any): null;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/ink.d.ts

@@ -0,0 +1,41 @@
+export class InkDrawingOptions extends DrawingOptions {
+    constructor(viewerParameters: any);
+    _viewParameters: any;
+    clone(): InkDrawingOptions;
+}
+/**
+ * Basic draw editor in order to generate an Ink annotation.
+ */
+export class InkEditor extends DrawingEditor {
+    static _type: string;
+    static _editorType: number;
+    static _defaultDrawingOptions: null;
+    /** @inheritdoc */
+    static initialize(l10n: any, uiManager: any): void;
+    /** @inheritdoc */
+    static getDefaultDrawingOptions(options: any): any;
+    /** @inheritdoc */
+    static get typesMap(): any;
+    /** @inheritdoc */
+    static createDrawerInstance(x: any, y: any, parentWidth: any, parentHeight: any, rotation: any): InkDrawOutliner;
+    /** @inheritdoc */
+    static deserializeDraw(pageX: any, pageY: any, pageWidth: any, pageHeight: any, innerMargin: any, data: any): any;
+    defaultL10nId: string;
+    /** @inheritdoc */
+    get toolbarButtons(): (string | null)[][];
+    get colorType(): number;
+    get colorValue(): any;
+    /** @inheritdoc */
+    createDrawingOptions({ color, thickness, opacity }: {
+        color: any;
+        thickness: any;
+        opacity: any;
+    }): void;
+    _drawingOptions: any;
+    /** @inheritdoc */
+    serialize(isForCopying?: boolean): Object | null;
+    #private;
+}
+import { DrawingOptions } from "./draw.js";
+import { DrawingEditor } from "./draw.js";
+import { InkDrawOutliner } from "./drawers/inkdraw.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/signature.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Basic editor in order to generate an Stamp annotation annotation containing
+ * a signature drawing.
+ */
+export class SignatureEditor extends DrawingEditor {
+    static _type: string;
+    static _editorType: number;
+    static _defaultDrawingOptions: null;
+    /** @inheritdoc */
+    static initialize(l10n: any, uiManager: any): void;
+    /** @inheritdoc */
+    static getDefaultDrawingOptions(options: any): any;
+    static get typesMap(): any;
+    static computeTelemetryFinalData(data: any): {
+        hasAltText: any;
+        hasNoAltText: any;
+    };
+    /** @inheritdoc */
+    static deserializeDraw(pageX: any, pageY: any, pageWidth: any, pageHeight: any, innerMargin: any, data: any): any;
+    defaultL10nId: string;
+    /** @inheritdoc */
+    get telemetryFinalData(): {
+        type: string;
+        hasDescription: boolean;
+    };
+    setUuid(uuid: any): void;
+    getUuid(): null;
+    set description(description: null);
+    get description(): null;
+    getSignaturePreview(): {
+        areContours: any;
+        outline: InkDrawOutline;
+    };
+    /** @inheritdoc */
+    get toolbarButtons(): any[][] | null;
+    addSignature(data: any, heightInPage: any, description: any, uuid: any): void;
+    getFromImage(bitmap: any): {
+        outline: InkDrawOutline;
+        newCurves: any[];
+        areContours: any;
+        thickness: any;
+        width: any;
+        height: any;
+    } | null;
+    getFromText(text: any, fontInfo: any): {
+        outline: InkDrawOutline;
+        newCurves: any[];
+        areContours: any;
+        thickness: any;
+        width: any;
+        height: any;
+    } | null;
+    getDrawnSignature(curves: any): {
+        outline: InkDrawOutline;
+        newCurves: any[];
+        areContours: any;
+        thickness: any;
+        width: any;
+        height: any;
+    } | null;
+    /** @inheritdoc */
+    createDrawingOptions({ areContours, thickness }: {
+        areContours: any;
+        thickness: any;
+    }): void;
+    _drawingOptions: any;
+    /** @inheritdoc */
+    serialize(isForCopying?: boolean): {
+        annotationType: number;
+        isSignature: boolean;
+        areContours: boolean;
+        color: number[];
+        thickness: any;
+        pageIndex: number;
+        rect: any;
+        rotation: number;
+        structTreeParentId: any;
+    } | null;
+    #private;
+}
+import { DrawingEditor } from "./draw.js";
+import { InkDrawOutline } from "./drawers/inkdraw.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/stamp.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Basic text editor in order to create a FreeTex annotation.
+ */
+export class StampEditor extends AnnotationEditor {
+    static _type: string;
+    static _editorType: number;
+    /** @inheritdoc */
+    static initialize(l10n: any, uiManager: any): void;
+    /** @inheritdoc */
+    static isHandlingMimeForPasting(mime: any): boolean;
+    /** @inheritdoc */
+    static paste(item: any, parent: any): void;
+    static computeTelemetryFinalData(data: any): {
+        hasAltText: any;
+        hasNoAltText: any;
+    };
+    /** @inheritdoc */
+    static deserialize(data: any, parent: any, uiManager: any): Promise<AnnotationEditor | null>;
+    constructor(params: any);
+    defaultL10nId: string;
+    /** @inheritdoc */
+    get telemetryFinalData(): {
+        type: string;
+        hasAltText: boolean;
+    };
+    mlGuessAltText(imageData?: null, updateAltTextData?: boolean): Promise<any>;
+    /** @inheritdoc */
+    onceAdded(focus: any): void;
+    /** @inheritdoc */
+    get toolbarButtons(): (string | object)[][];
+    setCanvas(annotationElementId: any, canvas: any): void;
+    onScaleChanging(): void;
+    copyCanvas(maxDataDimension: any, maxPreviewDimension: any, createImageData?: boolean): {
+        canvas: HTMLCanvasElement | null;
+        width: any;
+        height: any;
+        imageData: {
+            width: any;
+            height: any;
+            data: Uint8ClampedArray<ArrayBufferLike>;
+        } | null;
+    };
+    /** @inheritdoc */
+    serialize(isForCopying?: boolean, context?: null): Object | null;
+    /** @inheritdoc */
+    renderAnnotationElement(annotation: any): null;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/toolbar.d.ts

@@ -0,0 +1,24 @@
+export class EditorToolbar {
+    static "__#3@#l10nRemove": null;
+    static "__#3@#pointerDown"(e: any): void;
+    constructor(editor: any);
+    render(): HTMLDivElement;
+    get div(): null;
+    hide(): void;
+    show(): void;
+    addDeleteButton(): void;
+    addAltText(altText: any): Promise<void>;
+    addComment(comment: any): void;
+    addColorPicker(colorPicker: any): void;
+    addEditSignatureButton(signatureManager: any): Promise<void>;
+    addButton(name: any, tool: any): Promise<void>;
+    updateEditSignatureButton(description: any): void;
+    remove(): void;
+    #private;
+}
+export class HighlightToolbar {
+    constructor(uiManager: any);
+    show(parent: any, boxes: any, isLTR: any): void;
+    hide(): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/editor/tools.d.ts

@@ -0,0 +1,429 @@
+export type AnnotationEditor = import("./editor.js").AnnotationEditor;
+export type AnnotationEditorLayer = import("./annotation_editor_layer.js").AnnotationEditorLayer;
+/**
+ * A pdf has several pages and each of them when it will rendered
+ * will have an AnnotationEditorLayer which will contain the some
+ * new Annotations associated to an editor in order to modify them.
+ *
+ * This class is used to manage all the different layers, editors and
+ * some action like copy/paste, undo/redo, ...
+ */
+export class AnnotationEditorUIManager {
+    static TRANSLATE_SMALL: number;
+    static TRANSLATE_BIG: number;
+    static get _keyboardManager(): any;
+    constructor(container: any, viewer: any, viewerAlert: any, altTextManager: any, commentManager: any, signatureManager: any, eventBus: any, pdfDocument: any, pageColors: any, highlightColors: any, enableHighlightFloatingButton: any, enableUpdatedAddImage: any, enableNewAltTextWhenAddingImage: any, mlManager: any, editorUndoBar: any, supportsPinchToZoom: any);
+    _editorUndoBar: null;
+    _signal: AbortSignal;
+    _eventBus: any;
+    viewParameters: {
+        realScale: number;
+        rotation: number;
+    };
+    isShiftKeyDown: boolean;
+    _supportsPinchToZoom: boolean;
+    destroy(): void;
+    combinedSignal(ac: any): AbortSignal;
+    get mlManager(): null;
+    get useNewAltTextFlow(): boolean;
+    get useNewAltTextWhenAddingImage(): boolean;
+    get hcmFilter(): any;
+    get direction(): any;
+    get _highlightColors(): any;
+    get highlightColors(): any;
+    get highlightColorNames(): any;
+    getNonHCMColor(color: any): any;
+    getNonHCMColorName(color: any): any;
+    /**
+     * Set the current drawing session.
+     * @param {AnnotationEditorLayer} layer
+     */
+    setCurrentDrawingSession(layer: AnnotationEditorLayer): void;
+    setMainHighlightColorPicker(colorPicker: any): void;
+    editAltText(editor: any, firstTime?: boolean): void;
+    hasCommentManager(): boolean;
+    editComment(editor: any, position: any): void;
+    getSignature(editor: any): void;
+    get signatureManager(): null;
+    switchToMode(mode: any, callback: any): void;
+    setPreference(name: any, value: any): void;
+    onSetPreference({ name, value }: {
+        name: any;
+        value: any;
+    }): void;
+    onPageChanging({ pageNumber }: {
+        pageNumber: any;
+    }): void;
+    focusMainContainer(): void;
+    findParent(x: any, y: any): any;
+    disableUserSelect(value?: boolean): void;
+    addShouldRescale(editor: any): void;
+    removeShouldRescale(editor: any): void;
+    onScaleChanging({ scale }: {
+        scale: any;
+    }): void;
+    onRotationChanging({ pagesRotation }: {
+        pagesRotation: any;
+    }): void;
+    highlightSelection(methodOfCreation?: string): void;
+    /**
+     * Add an editor in the annotation storage.
+     * @param {AnnotationEditor} editor
+     */
+    addToAnnotationStorage(editor: AnnotationEditor): void;
+    a11yAlert(messageId: any, args?: null): void;
+    blur(): void;
+    focus(): void;
+    addEditListeners(): void;
+    removeEditListeners(): void;
+    dragOver(event: any): void;
+    /**
+     * Drop callback.
+     * @param {DragEvent} event
+     */
+    drop(event: DragEvent): void;
+    /**
+     * Copy callback.
+     * @param {ClipboardEvent} event
+     */
+    copy(event: ClipboardEvent): void;
+    /**
+     * Cut callback.
+     * @param {ClipboardEvent} event
+     */
+    cut(event: ClipboardEvent): void;
+    /**
+     * Paste callback.
+     * @param {ClipboardEvent} event
+     */
+    paste(event: ClipboardEvent): Promise<void>;
+    /**
+     * Keydown callback.
+     * @param {KeyboardEvent} event
+     */
+    keydown(event: KeyboardEvent): void;
+    /**
+     * Keyup callback.
+     * @param {KeyboardEvent} event
+     */
+    keyup(event: KeyboardEvent): void;
+    /**
+     * Execute an action for a given name.
+     * For example, the user can click on the "Undo" entry in the context menu
+     * and it'll trigger the undo action.
+     */
+    onEditingAction({ name }: {
+        name: any;
+    }): void;
+    /**
+     * Set the editing state.
+     * It can be useful to temporarily disable it when the user is editing a
+     * FreeText annotation.
+     * @param {boolean} isEditing
+     */
+    setEditingState(isEditing: boolean): void;
+    registerEditorTypes(types: any): void;
+    /**
+     * Get an id.
+     * @returns {string}
+     */
+    getId(): string;
+    get currentLayer(): any;
+    getLayer(pageIndex: any): any;
+    get currentPageIndex(): number;
+    /**
+     * Add a new layer for a page which will contains the editors.
+     * @param {AnnotationEditorLayer} layer
+     */
+    addLayer(layer: AnnotationEditorLayer): void;
+    /**
+     * Remove a layer.
+     * @param {AnnotationEditorLayer} layer
+     */
+    removeLayer(layer: AnnotationEditorLayer): void;
+    /**
+     * Change the editor mode (None, FreeText, Ink, ...)
+     * @param {number} mode
+     * @param {string|null} editId
+     * @param {boolean} [isFromKeyboard] - true if the mode change is due to a
+     *   keyboard action.
+     * @param {boolean} [mustEnterInEditMode] - true if the editor must enter in
+     *   edit mode.
+     * @param {boolean} [editComment] - true if the mode change is due to a
+     *   comment edit.
+     */
+    updateMode(mode: number, editId?: string | null, isFromKeyboard?: boolean, mustEnterInEditMode?: boolean, editComment?: boolean): Promise<void>;
+    addNewEditorFromKeyboard(): void;
+    /**
+     * Update the toolbar if it's required to reflect the tool currently used.
+     * @param {Object} options
+     * @param {number} mode
+     * @returns {undefined}
+     */
+    updateToolbar(options: Object): undefined;
+    /**
+     * Update a parameter in the current editor or globally.
+     * @param {number} type
+     * @param {*} value
+     */
+    updateParams(type: number, value: any): void;
+    showAllEditors(type: any, visible: any, updateButton?: boolean): void;
+    enableWaiting(mustWait?: boolean): void;
+    /**
+     * Get all the editors belonging to a given page.
+     * @param {number} pageIndex
+     * @returns {Array<AnnotationEditor>}
+     */
+    getEditors(pageIndex: number): Array<AnnotationEditor>;
+    /**
+     * Get an editor with the given id.
+     * @param {string} id
+     * @returns {AnnotationEditor}
+     */
+    getEditor(id: string): AnnotationEditor;
+    /**
+     * Add a new editor.
+     * @param {AnnotationEditor} editor
+     */
+    addEditor(editor: AnnotationEditor): void;
+    /**
+     * Remove an editor.
+     * @param {AnnotationEditor} editor
+     */
+    removeEditor(editor: AnnotationEditor): void;
+    /**
+     * The annotation element with the given id has been deleted.
+     * @param {AnnotationEditor} editor
+     */
+    addDeletedAnnotationElement(editor: AnnotationEditor): void;
+    /**
+     * Check if the annotation element with the given id has been deleted.
+     * @param {string} annotationElementId
+     * @returns {boolean}
+     */
+    isDeletedAnnotationElement(annotationElementId: string): boolean;
+    /**
+     * The annotation element with the given id have been restored.
+     * @param {AnnotationEditor} editor
+     */
+    removeDeletedAnnotationElement(editor: AnnotationEditor): void;
+    /**
+     * Set the given editor as the active one.
+     * @param {AnnotationEditor} editor
+     */
+    setActiveEditor(editor: AnnotationEditor): void;
+    /**
+     * Update the UI of the active editor.
+     * @param {AnnotationEditor} editor
+     */
+    updateUI(editor: AnnotationEditor): void;
+    updateUIForDefaultProperties(editorType: any): void;
+    /**
+     * Add or remove an editor the current selection.
+     * @param {AnnotationEditor} editor
+     */
+    toggleSelected(editor: AnnotationEditor): void;
+    /**
+     * Set the last selected editor.
+     * @param {AnnotationEditor} editor
+     */
+    setSelected(editor: AnnotationEditor): void;
+    /**
+     * Check if the editor is selected.
+     * @param {AnnotationEditor} editor
+     */
+    isSelected(editor: AnnotationEditor): boolean;
+    get firstSelectedEditor(): any;
+    /**
+     * Unselect an editor.
+     * @param {AnnotationEditor} editor
+     */
+    unselect(editor: AnnotationEditor): void;
+    get hasSelection(): boolean;
+    get isEnterHandled(): any;
+    /**
+     * Undo the last command.
+     */
+    undo(): void;
+    /**
+     * Redo the last undoed command.
+     */
+    redo(): void;
+    /**
+     * Add a command to execute (cmd) and another one to undo it.
+     * @param {Object} params
+     */
+    addCommands(params: Object): void;
+    cleanUndoStack(type: any): void;
+    /**
+     * Delete the current editor or all.
+     */
+    delete(): void;
+    commitOrRemove(): void;
+    hasSomethingToControl(): boolean;
+    /**
+     * Select all the editors.
+     */
+    selectAll(): void;
+    /**
+     * Unselect all the selected editors.
+     */
+    unselectAll(): void;
+    translateSelectedEditors(x: any, y: any, noCommit?: boolean): void;
+    /**
+     * Set up the drag session for moving the selected editors.
+     */
+    setUpDragSession(): void;
+    /**
+     * Ends the drag session.
+     * @returns {boolean} true if at least one editor has been moved.
+     */
+    endDragSession(): boolean;
+    /**
+     * Drag the set of selected editors.
+     * @param {number} tx
+     * @param {number} ty
+     */
+    dragSelectedEditors(tx: number, ty: number): void;
+    /**
+     * Rebuild the editor (usually on undo/redo actions) on a potentially
+     * non-rendered page.
+     * @param {AnnotationEditor} editor
+     */
+    rebuild(editor: AnnotationEditor): void;
+    get isEditorHandlingKeyboard(): any;
+    /**
+     * Is the current editor the one passed as argument?
+     * @param {AnnotationEditor} editor
+     * @returns
+     */
+    isActive(editor: AnnotationEditor): editor is never;
+    /**
+     * Get the current active editor.
+     * @returns {AnnotationEditor|null}
+     */
+    getActive(): AnnotationEditor | null;
+    /**
+     * Get the current editor mode.
+     * @returns {number}
+     */
+    getMode(): number;
+    get imageManager(): any;
+    getSelectionBoxes(textLayer: any): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[] | null;
+    addChangedExistingAnnotation({ annotationElementId, id }: {
+        annotationElementId: any;
+        id: any;
+    }): void;
+    removeChangedExistingAnnotation({ annotationElementId }: {
+        annotationElementId: any;
+    }): void;
+    renderAnnotationElement(annotation: any): void;
+    setMissingCanvas(annotationId: any, annotationElementId: any, canvas: any): void;
+    addMissingCanvas(annotationId: any, editor: any): void;
+    #private;
+}
+export function bindEvents(obj: any, element: any, names: any): void;
+export class ColorManager {
+    static _colorsMapping: Map<string, number[]>;
+    get _colors(): any;
+    /**
+     * In High Contrast Mode, the color on the screen is not always the
+     * real color used in the pdf.
+     * For example in some cases white can appear to be black but when saving
+     * we want to have white.
+     * @param {string} color
+     * @returns {Array<number>}
+     */
+    convert(color: string): Array<number>;
+    /**
+     * An input element must have its color value as a hex string
+     * and not as color name.
+     * So this function converts a name into an hex string.
+     * @param {string} name
+     * @returns {string}
+     */
+    getHexCode(name: string): string;
+}
+/**
+ * Class to handle undo/redo.
+ * Commands are just saved in a buffer.
+ * If we hit some memory issues we could likely use a circular buffer.
+ * It has to be used as a singleton.
+ */
+export class CommandManager {
+    constructor(maxSize?: number);
+    /**
+     * @typedef {Object} addOptions
+     * @property {function} cmd
+     * @property {function} undo
+     * @property {function} [post]
+     * @property {boolean} mustExec
+     * @property {number} type
+     * @property {boolean} overwriteIfSameType
+     * @property {boolean} keepUndo
+     */
+    /**
+     * Add a new couple of commands to be used in case of redo/undo.
+     * @param {addOptions} options
+     */
+    add({ cmd, undo, post, mustExec, type, overwriteIfSameType, keepUndo, }: {
+        cmd: Function;
+        undo: Function;
+        post?: Function | undefined;
+        mustExec: boolean;
+        type: number;
+        overwriteIfSameType: boolean;
+        keepUndo: boolean;
+    }): void;
+    /**
+     * Undo the last command.
+     */
+    undo(): void;
+    /**
+     * Redo the last command.
+     */
+    redo(): void;
+    /**
+     * Check if there is something to undo.
+     * @returns {boolean}
+     */
+    hasSomethingToUndo(): boolean;
+    /**
+     * Check if there is something to redo.
+     * @returns {boolean}
+     */
+    hasSomethingToRedo(): boolean;
+    cleanType(type: any): void;
+    destroy(): void;
+    #private;
+}
+/**
+ * Class to handle the different keyboards shortcuts we can have on mac or
+ * non-mac OSes.
+ */
+export class KeyboardManager {
+    /**
+     * Create a new keyboard manager class.
+     * @param {Array<Array>} callbacks - an array containing an array of shortcuts
+     * and a callback to call.
+     * A shortcut is a string like `ctrl+c` or `mac+ctrl+c` for mac OS.
+     */
+    constructor(callbacks: Array<any[]>);
+    buffer: any[];
+    callbacks: Map<any, any>;
+    allKeys: Set<any>;
+    /**
+     * Execute a callback, if any, for a given keyboard event.
+     * The self is used as `this` in the callback.
+     * @param {Object} self
+     * @param {KeyboardEvent} event
+     * @returns
+     */
+    exec(self: Object, event: KeyboardEvent): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/fetch_stream.d.ts

@@ -0,0 +1,60 @@
+/** @implements {IPDFStream} */
+export class PDFFetchStream implements IPDFStream {
+    constructor(source: any);
+    _responseOrigin: null;
+    source: any;
+    isHttp: boolean;
+    headers: Headers;
+    _fullRequestReader: PDFFetchStreamReader | null;
+    _rangeRequestReaders: any[];
+    get _progressiveDataLength(): number;
+    getFullReader(): PDFFetchStreamReader;
+    getRangeReader(begin: any, end: any): PDFFetchStreamRangeReader | null;
+    cancelAllRequests(reason: any): void;
+}
+/** @implements {IPDFStreamReader} */
+declare class PDFFetchStreamReader implements IPDFStreamReader {
+    constructor(stream: any);
+    _stream: any;
+    _reader: ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>> | null;
+    _loaded: number;
+    _filename: string | null;
+    _withCredentials: any;
+    _contentLength: any;
+    _headersCapability: any;
+    _disableRange: any;
+    _rangeChunkSize: any;
+    _abortController: AbortController;
+    _isStreamingSupported: boolean;
+    _isRangeSupported: boolean;
+    onProgress: any;
+    get headersReady(): any;
+    get filename(): string | null;
+    get contentLength(): any;
+    get isRangeSupported(): boolean;
+    get isStreamingSupported(): boolean;
+    read(): Promise<{
+        value: any;
+        done: boolean;
+    }>;
+    cancel(reason: any): void;
+}
+/** @implements {IPDFStreamRangeReader} */
+declare class PDFFetchStreamRangeReader implements IPDFStreamRangeReader {
+    constructor(stream: any, begin: any, end: any);
+    _stream: any;
+    _reader: ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>> | null;
+    _loaded: number;
+    _withCredentials: any;
+    _readCapability: any;
+    _isStreamingSupported: boolean;
+    _abortController: AbortController;
+    onProgress: any;
+    get isStreamingSupported(): boolean;
+    read(): Promise<{
+        value: any;
+        done: boolean;
+    }>;
+    cancel(reason: any): void;
+}
+export {};

tools/ui/node_modules/pdfjs-dist/types/src/display/filter_factory.d.ts

@@ -0,0 +1,29 @@
+export class BaseFilterFactory {
+    addFilter(maps: any): string;
+    addHCMFilter(fgColor: any, bgColor: any): string;
+    addAlphaFilter(map: any): string;
+    addLuminosityFilter(map: any): string;
+    addHighlightHCMFilter(filterName: any, fgColor: any, bgColor: any, newFgColor: any, newBgColor: any): string;
+    destroy(keepHCM?: boolean): void;
+}
+/**
+ * FilterFactory aims to create some SVG filters we can use when drawing an
+ * image (or whatever) on a canvas.
+ * Filters aren't applied with ctx.putImageData because it just overwrites the
+ * underlying pixels.
+ * With these filters, it's possible for example to apply some transfer maps on
+ * an image without the need to apply them on the pixel arrays: the renderer
+ * does the magic for us.
+ */
+export class DOMFilterFactory extends BaseFilterFactory {
+    constructor({ docId, ownerDocument }: {
+        docId: any;
+        ownerDocument?: Document | undefined;
+    });
+    addFilter(maps: any): any;
+    addHCMFilter(fgColor: any, bgColor: any): any;
+    addAlphaFilter(map: any): any;
+    addLuminosityFilter(map: any): any;
+    addHighlightHCMFilter(filterName: any, fgColor: any, bgColor: any, newFgColor: any, newBgColor: any): any;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/font_loader.d.ts

@@ -0,0 +1,39 @@
+export class FontFaceObject {
+    constructor(translatedData: any, inspectFont?: null);
+    compiledGlyphs: any;
+    _inspectFont: any;
+    createNativeFontFace(): FontFace | null;
+    createFontFaceRule(): string | null;
+    getPathGenerator(objs: any, character: any): any;
+}
+export class FontLoader {
+    constructor({ ownerDocument, styleElement, }: {
+        ownerDocument?: Document | undefined;
+        styleElement?: null | undefined;
+    });
+    _document: Document;
+    nativeFontFaces: Set<any>;
+    styleElement: HTMLStyleElement | null;
+    loadingRequests: any[] | undefined;
+    loadTestFontId: number | undefined;
+    addNativeFontFace(nativeFontFace: any): void;
+    removeNativeFontFace(nativeFontFace: any): void;
+    insertRule(rule: any): void;
+    clear(): void;
+    loadSystemFont({ systemFontInfo: info, disableFontFace, _inspectFont, }: {
+        systemFontInfo: any;
+        disableFontFace: any;
+        _inspectFont: any;
+    }): Promise<void>;
+    bind(font: any): Promise<void>;
+    get isFontLoadingAPISupported(): any;
+    get isSyncFontLoadingSupported(): any;
+    _queueLoadingCallback(callback: any): {
+        done: boolean;
+        complete: () => void;
+        callback: any;
+    };
+    get _loadTestFont(): any;
+    _prepareFontLoadEvent(font: any, request: any): void;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/metadata.d.ts

@@ -0,0 +1,10 @@
+export class Metadata {
+    constructor({ parsedData, rawData }: {
+        parsedData: any;
+        rawData: any;
+    });
+    getRaw(): any;
+    get(name: any): any;
+    [Symbol.iterator](): any;
+    #private;
+}

tools/ui/node_modules/pdfjs-dist/types/src/display/network.d.ts

@@ -0,0 +1,86 @@
+/** @implements {IPDFStream} */
+export class PDFNetworkStream implements IPDFStream {
+    constructor(source: any);
+    _source: any;
+    _manager: NetworkManager;
+    _rangeChunkSize: any;
+    _fullRequestReader: PDFNetworkStreamFullRequestReader | null;
+    _rangeRequestReaders: any[];
+    _onRangeRequestReaderClosed(reader: any): void;
+    getFullReader(): PDFNetworkStreamFullRequestReader;
+    getRangeReader(begin: any, end: any): PDFNetworkStreamRangeRequestReader;
+    cancelAllRequests(reason: any): void;
+}
+declare class NetworkManager {
+    constructor({ url, httpHeaders, withCredentials }: {
+        url: any;
+        httpHeaders: any;
+        withCredentials: any;
+    });
+    _responseOrigin: null;
+    url: any;
+    isHttp: boolean;
+    headers: Headers;
+    withCredentials: any;
+    currXhrId: number;
+    pendingRequests: any;
+    request(args: any): number;
+    onProgress(xhrId: any, evt: any): void;
+    onStateChange(xhrId: any, evt: any): void;
+    getRequestXhr(xhrId: any): any;
+    isPendingRequest(xhrId: any): boolean;
+    abortRequest(xhrId: any): void;
+}
+/** @implements {IPDFStreamReader} */
+declare class PDFNetworkStreamFullRequestReader implements IPDFStreamReader {
+    constructor(manager: any, source: any);
+    _manager: any;
+    _url: any;
+    _fullRequestId: any;
+    _headersCapability: any;
+    _disableRange: any;
+    _contentLength: any;
+    _rangeChunkSize: any;
+    _isStreamingSupported: boolean;
+    _isRangeSupported: boolean;
+    _cachedChunks: any[];
+    _requests: any[];
+    _done: boolean;
+    _storedError: import("../shared/util.js").ResponseException | undefined;
+    _filename: string | null;
+    onProgress: any;
+    _onHeadersReceived(): void;
+    _onDone(data: any): void;
+    _onError(status: any): void;
+    _onProgress(evt: any): void;
+    get filename(): string | null;
+    get isRangeSupported(): boolean;
+    get isStreamingSupported(): boolean;
+    get contentLength(): any;
+    get headersReady(): any;
+    read(): Promise<any>;
+    cancel(reason: any): void;
+    _fullRequestReader: any;
+}
+/** @implements {IPDFStreamRangeReader} */
+declare class PDFNetworkStreamRangeRequestReader implements IPDFStreamRangeReader {
+    constructor(manager: any, begin: any, end: any);
+    _manager: any;
+    _url: any;
+    _requestId: any;
+    _requests: any[];
+    _queuedChunk: any;
+    _done: boolean;
+    _storedError: Error | undefined;
+    onProgress: any;
+    onClosed: any;
+    _onHeadersReceived(): void;
+    _close(): void;
+    _onDone(data: any): void;
+    _onError(status: any): void;
+    _onProgress(evt: any): void;
+    get isStreamingSupported(): boolean;
+    read(): Promise<any>;
+    cancel(reason: any): void;
+}
+export {};

tools/ui/node_modules/pdfjs-dist/types/src/display/network_utils.d.ts

@@ -0,0 +1,15 @@
+export function createHeaders(isHttp: any, httpHeaders: any): Headers;
+export function createResponseError(status: any, url: any): ResponseException;
+export function extractFilenameFromHeader(responseHeaders: any): string | null;
+export function getResponseOrigin(url: any): string | null;
+export function validateRangeRequestCapabilities({ responseHeaders, isHttp, rangeChunkSize, disableRange, }: {
+    responseHeaders: any;
+    isHttp: any;
+    rangeChunkSize: any;
+    disableRange: any;
+}): {
+    allowRangeRequests: boolean;
+    suggestedLength: undefined;
+};
+export function validateResponseStatus(status: any): boolean;
+import { ResponseException } from "../shared/util.js";

tools/ui/node_modules/pdfjs-dist/types/src/display/node_stream.d.ts

@@ -0,0 +1,54 @@
+export class PDFNodeStream {
+    constructor(source: any);
+    source: any;
+    url: URL;
+    _fullRequestReader: PDFNodeStreamFsFullReader | null;
+    _rangeRequestReaders: any[];
+    get _progressiveDataLength(): number;
+    getFullReader(): PDFNodeStreamFsFullReader;
+    getRangeReader(start: any, end: any): PDFNodeStreamFsRangeReader | null;
+    cancelAllRequests(reason: any): void;
+}
+declare class PDFNodeStreamFsFullReader {
+    constructor(stream: any);
+    _url: any;
+    _done: boolean;
+    _storedError: any;
+    onProgress: any;
+    _contentLength: any;
+    _loaded: number;
+    _filename: any;
+    _disableRange: any;
+    _rangeChunkSize: any;
+    _isStreamingSupported: boolean;
+    _isRangeSupported: boolean;
+    _readableStream: any;
+    _readCapability: any;
+    _headersCapability: any;
+    get headersReady(): any;
+    get filename(): any;
+    get contentLength(): any;
+    get isRangeSupported(): boolean;
+    get isStreamingSupported(): boolean;
+    read(): any;
+    cancel(reason: any): void;
+    _error(reason: any): void;
+    _setReadableStream(readableStream: any): void;
+}
+declare class PDFNodeStreamFsRangeReader {
+    constructor(stream: any, start: any, end: any);
+    _url: any;
+    _done: boolean;
+    _storedError: any;
+    onProgress: any;
+    _loaded: number;
+    _readableStream: any;
+    _readCapability: any;
+    _isStreamingSupported: boolean;
+    get isStreamingSupported(): boolean;
+    read(): any;
+    cancel(reason: any): void;
+    _error(reason: any): void;
+    _setReadableStream(readableStream: any): void;
+}
+export {};

tools/ui/node_modules/pdfjs-dist/types/src/display/node_utils.d.ts

@@ -0,0 +1,32 @@
+export function fetchData(url: any): Promise<Uint8Array<ArrayBuffer>>;
+export class NodeCanvasFactory extends BaseCanvasFactory {
+    /**
+     * @ignore
+     */
+    _createCanvas(width: any, height: any): import("@napi-rs/canvas").Canvas;
+}
+export class NodeCMapReaderFactory extends BaseCMapReaderFactory {
+    /**
+     * @ignore
+     */
+    _fetch(url: any): Promise<Uint8Array<ArrayBuffer>>;
+}
+export class NodeFilterFactory extends BaseFilterFactory {
+}
+export class NodeStandardFontDataFactory extends BaseStandardFontDataFactory {
+    /**
+     * @ignore
+     */
+    _fetch(url: any): Promise<Uint8Array<ArrayBuffer>>;
+}
+export class NodeWasmFactory extends BaseWasmFactory {
+    /**
+     * @ignore
+     */
+    _fetch(url: any): Promise<Uint8Array<ArrayBuffer>>;
+}
+import { BaseCanvasFactory } from "./canvas_factory.js";
+import { BaseCMapReaderFactory } from "./cmap_reader_factory.js";
+import { BaseFilterFactory } from "./filter_factory.js";
+import { BaseStandardFontDataFactory } from "./standard_fontdata_factory.js";
+import { BaseWasmFactory } from "./wasm_factory.js";