@foxycape/core 1.1.3

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

@@ -0,0 +1,410 @@
+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, altTextManager: any, eventBus: any, pdfDocument: any, pageColors: any, highlightColors: any, enableHighlightFloatingButton: any, enableUpdatedAddImage: any, enableNewAltTextWhenAddingImage: any, mlManager: any);
+    _signal: AbortSignal;
+    _eventBus: any;
+    viewParameters: {
+        realScale: number;
+        rotation: number;
+    };
+    isShiftKeyDown: 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 highlightColorNames(): any;
+    setMainHighlightColorPicker(colorPicker: any): void;
+    editAltText(editor: any, firstTime?: boolean): void;
+    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;
+    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.
+     */
+    updateMode(mode: number, editId?: string | null, isFromKeyboard?: boolean | undefined): Promise<void>;
+    addNewEditorFromKeyboard(): 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;
+    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;
+    /**
+     * 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;
+    /**
+     * 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;
+    #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;
+    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;
+}
+/**
+ * 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/dist/pdfjs/types/src/display/fetch_stream.d.ts

@@ -0,0 +1,65 @@
+/** @implements {IPDFStream} */
+export class PDFFetchStream implements IPDFStream {
+    constructor(source: any);
+    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> | 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: Uint8Array | undefined;
+        done: true;
+    } | {
+        value: ArrayBufferLike;
+        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> | null;
+    _loaded: number;
+    _withCredentials: any;
+    _readCapability: any;
+    _isStreamingSupported: boolean;
+    _abortController: AbortController;
+    onProgress: any;
+    get isStreamingSupported(): boolean;
+    read(): Promise<{
+        value: Uint8Array | undefined;
+        done: true;
+    } | {
+        value: ArrayBufferLike;
+        done: boolean;
+    }>;
+    cancel(reason: any): void;
+}
+export {};

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

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

package/dist/pdfjs/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/dist/pdfjs/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;
+    });
+    url: any;
+    isHttp: boolean;
+    headers: Headers;
+    withCredentials: any;
+    currXhrId: number;
+    pendingRequests: any;
+    requestRange(begin: any, end: any, listeners: any): number;
+    requestFull(listeners: any): number;
+    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").MissingPDFException | import("../shared/util.js").UnexpectedResponseException | 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: import("../shared/util.js").MissingPDFException | import("../shared/util.js").UnexpectedResponseException | undefined;
+    onProgress: any;
+    onClosed: any;
+    _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 {};

package/dist/pdfjs/types/src/display/network_utils.d.ts

@@ -0,0 +1,15 @@
+export function createHeaders(isHttp: any, httpHeaders: any): Headers;
+export function createResponseStatusError(status: any, url: any): MissingPDFException | UnexpectedResponseException;
+export function extractFilenameFromHeader(responseHeaders: 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 { MissingPDFException } from "../shared/util.js";
+import { UnexpectedResponseException } from "../shared/util.js";

package/dist/pdfjs/types/src/display/node_stream.d.ts

@@ -0,0 +1,69 @@
+export class PDFNodeStream {
+    constructor(source: any);
+    source: any;
+    url: URL;
+    isHttp: boolean;
+    isFsUrl: boolean;
+    headers: Headers;
+    _fullRequestReader: PDFNodeStreamFsFullReader | PDFNodeStreamFullReader | null;
+    _rangeRequestReaders: any[];
+    get _progressiveDataLength(): number;
+    getFullReader(): PDFNodeStreamFsFullReader | PDFNodeStreamFullReader;
+    getRangeReader(start: any, end: any): PDFNodeStreamFsRangeReader | PDFNodeStreamRangeReader | null;
+    cancelAllRequests(reason: any): void;
+}
+declare class PDFNodeStreamFsFullReader extends BaseFullReader {
+}
+declare class PDFNodeStreamFullReader extends BaseFullReader {
+    _request: any;
+}
+declare class PDFNodeStreamFsRangeReader extends BaseRangeReader {
+    constructor(stream: any, start: any, end: any);
+}
+declare class PDFNodeStreamRangeReader extends BaseRangeReader {
+    constructor(stream: any, start: any, end: any);
+    _request: any;
+}
+declare class BaseFullReader {
+    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 BaseRangeReader {
+    constructor(stream: 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 {};