@divriots/pdfjs-dist 3.10.111-divriots2.0

package/types/src/display/editor/stamp.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Basic text editor in order to create a FreeTex annotation.
+ */
+export class StampEditor extends AnnotationEditor {
+    static _type: string;
+    static get supportedTypes(): any;
+    static get supportedTypesStr(): any;
+    /** @inheritdoc */
+    static isHandlingMimeForPasting(mime: any): any;
+    /** @inheritdoc */
+    static paste(item: any, parent: any): void;
+    /** @inheritdoc */
+    static deserialize(data: any, parent: any, uiManager: any): AnnotationEditor | null;
+    constructor(params: any);
+    /** @inheritdoc */
+    render(): HTMLDivElement | null;
+    /** @inheritdoc */
+    serialize(isForCopying?: boolean, context?: null): {
+        annotationType: number;
+        bitmapId: null;
+        pageIndex: number;
+        rect: any[];
+        rotation: number;
+        isSvg: boolean;
+    } | null;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";

package/types/src/display/editor/tools.d.ts

@@ -0,0 +1,349 @@
+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, eventBus: any, pdfDocument: any, pageColors: any);
+    viewParameters: {
+        realScale: number;
+        rotation: number;
+    };
+    destroy(): void;
+    get hcmFilter(): any;
+    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;
+    /**
+     * Add an editor in the annotation storage.
+     * @param {AnnotationEditor} editor
+     */
+    addToAnnotationStorage(editor: AnnotationEditor): void;
+    blur(): void;
+    focus(): 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): void;
+    /**
+     * Keydown callback.
+     * @param {KeyboardEvent} event
+     */
+    keydown(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.
+     * @param {Object} details
+     */
+    onEditingAction(details: Object): 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
+     */
+    updateMode(mode: number, editId?: string | null): void;
+    /**
+     * Update the toolbar if it's required to reflect the tool currently used.
+     * @param {number} mode
+     * @returns {undefined}
+     */
+    updateToolbar(mode: number): undefined;
+    /**
+     * Update a parameter in the current editor or globally.
+     * @param {number} type
+     * @param {*} value
+     */
+    updateParams(type: number, value: any): 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;
+    /**
+     * 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;
+    /**
+     * Unselect an editor.
+     * @param {AnnotationEditor} editor
+     */
+    unselect(editor: AnnotationEditor): void;
+    get hasSelection(): boolean;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Is the current editor the one passed as argument?
+     * @param {AnnotationEditor} editor
+     * @returns
+     */
+    isActive(editor: AnnotationEditor): boolean;
+    /**
+     * Get the current active editor.
+     * @returns {AnnotationEditor|null}
+     */
+    getActive(): AnnotationEditor | null;
+    /**
+     * Get the current editor mode.
+     * @returns {number}
+     */
+    getMode(): number;
+    get imageManager(): any;
+    #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 {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, mustExec, type, overwriteIfSameType, keepUndo, }: {
+        cmd: Function;
+        undo: Function;
+        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;
+    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: any, event: KeyboardEvent): void;
+    #private;
+}
+/**
+ * Convert a number between 0 and 100 into an hex number between 0 and 255.
+ * @param {number} opacity
+ * @return {string}
+ */
+export function opacityToHex(opacity: number): string;

package/types/src/display/font_loader.d.ts

@@ -0,0 +1,43 @@
+export class FontFaceObject {
+    constructor(translatedData: any, { isEvalSupported, disableFontFace, ignoreErrors, inspectFont, }: {
+        isEvalSupported?: boolean | undefined;
+        disableFontFace?: boolean | undefined;
+        ignoreErrors?: boolean | undefined;
+        inspectFont?: null | undefined;
+    });
+    compiledGlyphs: any;
+    isEvalSupported: boolean;
+    disableFontFace: boolean;
+    ignoreErrors: boolean;
+    _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(info: 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;
+}

package/types/src/display/metadata.d.ts

@@ -0,0 +1,11 @@
+export class Metadata {
+    constructor({ parsedData, rawData }: {
+        parsedData: any;
+        rawData: any;
+    });
+    getRaw(): any;
+    get(name: any): any;
+    getAll(): any;
+    has(name: any): any;
+    #private;
+}

package/types/src/display/optional_content_config.d.ts

@@ -0,0 +1,13 @@
+export class OptionalContentConfig {
+    constructor(data: any);
+    name: any;
+    creator: any;
+    isVisible(group: any): any;
+    setVisibility(id: any, visible?: boolean): void;
+    get hasInitialVisibility(): boolean;
+    getOrder(): any;
+    getGroups(): any;
+    getGroup(id: any): any;
+    getHash(): string;
+    #private;
+}

package/types/src/display/pattern_helper.d.ts

@@ -0,0 +1,73 @@
+export function getShadingPattern(IR: any): RadialAxialShadingPattern | MeshShadingPattern | DummyShadingPattern;
+export namespace PathType {
+    let FILL: string;
+    let STROKE: string;
+    let SHADING: string;
+}
+export class TilingPattern {
+    static MAX_PATTERN_SIZE: number;
+    constructor(IR: any, color: any, ctx: any, canvasGraphicsFactory: any, baseTransform: any);
+    operatorList: any;
+    matrix: any;
+    bbox: any;
+    xstep: any;
+    ystep: any;
+    paintType: any;
+    tilingType: any;
+    color: any;
+    ctx: any;
+    canvasGraphicsFactory: any;
+    baseTransform: any;
+    createPatternCanvas(owner: any): {
+        canvas: any;
+        scaleX: any;
+        scaleY: any;
+        offsetX: any;
+        offsetY: any;
+    };
+    getSizeAndScale(step: any, realOutputSize: any, scale: any): {
+        scale: any;
+        size: number;
+    };
+    clipBbox(graphics: any, x0: any, y0: any, x1: any, y1: any): void;
+    setFillAndStrokeStyleToContext(graphics: any, paintType: any, color: any): void;
+    getPattern(ctx: any, owner: any, inverse: any, pathType: any): any;
+}
+declare class RadialAxialShadingPattern extends BaseShadingPattern {
+    constructor(IR: any);
+    _type: any;
+    _bbox: any;
+    _colorStops: any;
+    _p0: any;
+    _p1: any;
+    _r0: any;
+    _r1: any;
+    matrix: any;
+    _createGradient(ctx: any): any;
+    getPattern(ctx: any, owner: any, inverse: any, pathType: any): any;
+}
+declare class MeshShadingPattern extends BaseShadingPattern {
+    constructor(IR: any);
+    _coords: any;
+    _colors: any;
+    _figures: any;
+    _bounds: any;
+    _bbox: any;
+    _background: any;
+    matrix: any;
+    _createMeshCanvas(combinedScale: any, backgroundColor: any, cachedCanvases: any): {
+        canvas: any;
+        offsetX: number;
+        offsetY: number;
+        scaleX: number;
+        scaleY: number;
+    };
+    getPattern(ctx: any, owner: any, inverse: any, pathType: any): any;
+}
+declare class DummyShadingPattern extends BaseShadingPattern {
+    getPattern(): string;
+}
+declare class BaseShadingPattern {
+    getPattern(): void;
+}
+export {};

package/types/src/display/text_layer.d.ts

@@ -0,0 +1,151 @@
+export type PageViewport = import("./display_utils").PageViewport;
+export type TextContent = import("./api").TextContent;
+/**
+ * Text layer render parameters.
+ */
+export type TextLayerRenderParameters = {
+    /**
+     * - Text content to
+     * render, i.e. the value returned by the page's `streamTextContent` or
+     * `getTextContent` method.
+     */
+    textContentSource: ReadableStream | TextContent;
+    /**
+     * - The DOM node that will contain the text
+     * runs.
+     */
+    container: HTMLElement;
+    /**
+     * - The target viewport to properly layout
+     * the text runs.
+     */
+    viewport: PageViewport;
+    /**
+     * - HTML elements that correspond to
+     * the text items of the textContent input.
+     * This is output and shall initially be set to an empty array.
+     */
+    textDivs?: HTMLElement[] | undefined;
+    /**
+     * - Some properties
+     * weakly mapped to the HTML elements used to render the text.
+     */
+    textDivProperties?: WeakMap<HTMLElement, Object> | undefined;
+    /**
+     * - Strings that correspond to
+     * the `str` property of the text items of the textContent input.
+     * This is output and shall initially be set to an empty array.
+     */
+    textContentItemsStr?: string[] | undefined;
+    /**
+     * true if we can use
+     * OffscreenCanvas to measure string widths.
+     */
+    isOffscreenCanvasSupported?: boolean | undefined;
+};
+/**
+ * Text layer update parameters.
+ */
+export type TextLayerUpdateParameters = {
+    /**
+     * - The DOM node that will contain the text
+     * runs.
+     */
+    container: HTMLElement;
+    /**
+     * - The target viewport to properly layout
+     * the text runs.
+     */
+    viewport: PageViewport;
+    /**
+     * - HTML elements that correspond to
+     * the text items of the textContent input.
+     * This is output and shall initially be set to an empty array.
+     */
+    textDivs?: HTMLElement[] | undefined;
+    /**
+     * - Some properties
+     * weakly mapped to the HTML elements used to render the text.
+     */
+    textDivProperties?: WeakMap<HTMLElement, Object> | undefined;
+    /**
+     * true if we can use
+     * OffscreenCanvas to measure string widths.
+     */
+    isOffscreenCanvasSupported?: boolean | undefined;
+    /**
+     * true if the text layer must be rotated.
+     */
+    mustRotate?: boolean | undefined;
+    /**
+     * true if the text layer contents must be
+     * rescaled.
+     */
+    mustRescale?: boolean | undefined;
+};
+/**
+ * @param {TextLayerRenderParameters} params
+ * @returns {TextLayerRenderTask}
+ */
+export function renderTextLayer(params: TextLayerRenderParameters): TextLayerRenderTask;
+export class TextLayerRenderTask {
+    constructor({ textContentSource, container, viewport, textDivs, textDivProperties, textContentItemsStr, isOffscreenCanvasSupported, }: {
+        textContentSource: any;
+        container: any;
+        viewport: any;
+        textDivs: any;
+        textDivProperties: any;
+        textContentItemsStr: any;
+        isOffscreenCanvasSupported: any;
+    });
+    _textContentSource: any;
+    _isReadableStream: boolean;
+    _container: any;
+    _rootContainer: any;
+    _textDivs: any;
+    _textContentItemsStr: any;
+    _isOffscreenCanvasSupported: any;
+    _fontInspectorEnabled: boolean;
+    _reader: any;
+    _textDivProperties: any;
+    _canceled: boolean;
+    _capability: PromiseCapability;
+    _layoutTextParams: {
+        prevFontSize: null;
+        prevFontFamily: null;
+        div: null;
+        scale: number;
+        properties: null;
+        ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;
+    };
+    _transform: any[];
+    _pageWidth: any;
+    _pageHeight: any;
+    /**
+     * Promise for textLayer rendering task completion.
+     * @type {Promise<void>}
+     */
+    get promise(): Promise<void>;
+    /**
+     * Cancel rendering of the textLayer.
+     */
+    cancel(): void;
+    /**
+     * @private
+     */
+    private _processItems;
+    /**
+     * @private
+     */
+    private _layoutText;
+    /**
+     * @private
+     */
+    private _render;
+}
+/**
+ * @param {TextLayerUpdateParameters} params
+ * @returns {undefined}
+ */
+export function updateTextLayer({ container, viewport, textDivs, textDivProperties, isOffscreenCanvasSupported, mustRotate, mustRescale, }: TextLayerUpdateParameters): undefined;
+import { PromiseCapability } from "../shared/util.js";