@progress/kendo-pdfviewer-common 0.3.0-dev.202409251459 → 0.3.0-dev.202410100645

package/dist/npm/annotations/shared/event_utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Simple event bus for an application. Listeners are attached using the `on`
+ * and `off` methods. To raise an event, the `dispatch` method shall be used.
+ */
+declare class EventBus {
+    #private;
+    /**
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {Object} [options]
+     */
+    on(eventName: any, listener: any, options?: any): void;
+    /**
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {Object} [options]
+     */
+    off(eventName: any, listener: any): void;
+    /**
+     * @param {string} eventName
+     * @param {Object} data
+     */
+    dispatch(eventName: any, data: any): void;
+    /**
+     * @ignore
+     */
+    _on(eventName: any, listener: any, options?: any): void;
+    /**
+     * @ignore
+     */
+    _off(eventName: any, listener: any): void;
+}
+export { EventBus, };

package/dist/npm/annotations/shared/event_utils.js

@@ -0,0 +1,165 @@
+"use strict";
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// const WaitOnType = {
+//     EVENT: "event",
+//     TIMEOUT: "timeout",
+// };
+var _EventBus_listeners;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+const tslib_1 = require("tslib");
+// /**
+//  * @typedef {Object} WaitOnEventOrTimeoutParameters
+//  * @property {Object} target - The event target, can for example be:
+//  *   `window`, `document`, a DOM element, or an {EventBus} instance.
+//  * @property {string} name - The name of the event.
+//  * @property {number} delay - The delay, in milliseconds, after which the
+//  *   timeout occurs (if the event wasn't already dispatched).
+//  */
+// /**
+//  * Allows waiting for an event or a timeout, whichever occurs first.
+//  * Can be used to ensure that an action always occurs, even when an event
+//  * arrives late or not at all.
+//  *
+//  * @param {WaitOnEventOrTimeoutParameters}
+//  * @returns {Promise} A promise that is resolved with a {WaitOnType} value.
+//  */
+// async function waitOnEventOrTimeout({ target, name, delay = 0 }) {
+//     if (
+//         typeof target !== "object" ||
+//         !(name && typeof name === "string") ||
+//         !(Number.isInteger(delay) && delay >= 0)
+//     ) {
+//         throw new Error("waitOnEventOrTimeout - invalid parameters.");
+//     }
+//     const { promise, resolve } = Promise.withResolvers();
+//     const ac = new AbortController();
+//     function handler(type) {
+//         ac.abort(); // Remove event listener.
+//         clearTimeout(timeout);
+//         resolve(type);
+//     }
+//     const evtMethod = target instanceof EventBus ? "_on" : "addEventListener";
+//     target[evtMethod](name, handler.bind(null, WaitOnType.EVENT), {
+//         signal: ac.signal,
+//     });
+//     const timeout = setTimeout(handler.bind(null, WaitOnType.TIMEOUT), delay);
+//     return promise;
+// }
+/**
+ * Simple event bus for an application. Listeners are attached using the `on`
+ * and `off` methods. To raise an event, the `dispatch` method shall be used.
+ */
+class EventBus {
+    constructor() {
+        _EventBus_listeners.set(this, Object.create(null));
+    }
+    /**
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {Object} [options]
+     */
+    on(eventName, listener, options = null) {
+        this._on(eventName, listener, {
+            external: true,
+            once: options === null || options === void 0 ? void 0 : options.once,
+            signal: options === null || options === void 0 ? void 0 : options.signal,
+        });
+    }
+    /**
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {Object} [options]
+     */
+    off(eventName, listener) {
+        this._off(eventName, listener);
+    }
+    /**
+     * @param {string} eventName
+     * @param {Object} data
+     */
+    dispatch(eventName, data) {
+        const eventListeners = tslib_1.__classPrivateFieldGet(this, _EventBus_listeners, "f")[eventName];
+        if (!eventListeners || eventListeners.length === 0) {
+            return;
+        }
+        let externalListeners;
+        // Making copy of the listeners array in case if it will be modified
+        // during dispatch.
+        for (const { listener, external, once } of eventListeners.slice(0)) {
+            if (once) {
+                this._off(eventName, listener);
+            }
+            if (external) {
+                (externalListeners || (externalListeners = [])).push(listener);
+                continue;
+            }
+            listener(data);
+        }
+        // Dispatch any "external" listeners *after* the internal ones, to give the
+        // viewer components time to handle events and update their state first.
+        if (externalListeners) {
+            for (const listener of externalListeners) {
+                listener(data);
+            }
+            externalListeners = null;
+        }
+    }
+    /**
+     * @ignore
+     */
+    _on(eventName, listener, options = null) {
+        var _a;
+        let rmAbort = null;
+        if ((options === null || options === void 0 ? void 0 : options.signal) instanceof AbortSignal) {
+            const { signal } = options;
+            if (signal.aborted) {
+                // console.error("Cannot use an `aborted` signal.");
+                return;
+            }
+            const onAbort = () => this._off(eventName, listener);
+            rmAbort = () => signal.removeEventListener("abort", onAbort);
+            signal.addEventListener("abort", onAbort);
+        }
+        const eventListeners = ((_a = tslib_1.__classPrivateFieldGet(this, _EventBus_listeners, "f"))[eventName] || (_a[eventName] = []));
+        eventListeners.push({
+            listener,
+            external: (options === null || options === void 0 ? void 0 : options.external) === true,
+            once: (options === null || options === void 0 ? void 0 : options.once) === true,
+            rmAbort,
+        });
+    }
+    /**
+     * @ignore
+     */
+    _off(eventName, listener) {
+        var _a;
+        const eventListeners = tslib_1.__classPrivateFieldGet(this, _EventBus_listeners, "f")[eventName];
+        if (!eventListeners) {
+            return;
+        }
+        for (let i = 0, ii = eventListeners.length; i < ii; i++) {
+            const evt = eventListeners[i];
+            if (evt.listener === listener) {
+                (_a = evt.rmAbort) === null || _a === void 0 ? void 0 : _a.call(evt); // Ensure that the `AbortSignal` listener is removed.
+                eventListeners.splice(i, 1);
+                return;
+            }
+        }
+    }
+}
+exports.EventBus = EventBus;
+_EventBus_listeners = new WeakMap();

package/dist/npm/annotations/shared/murmurhash3.d.ts

@@ -0,0 +1,8 @@
+declare class MurmurHash3_64 {
+    h1: any;
+    h2: any;
+    constructor(seed: any);
+    update(input: any): void;
+    hexdigest(): string;
+}
+export { MurmurHash3_64 };

package/dist/npm/annotations/shared/murmurhash3.js

@@ -0,0 +1,129 @@
+"use strict";
+/* Copyright 2014 Opera Software ASA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * Based on https://code.google.com/p/smhasher/wiki/MurmurHash3.
+ * Hashes roughly 100 KB per millisecond on i7 3.4 GHz.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MurmurHash3_64 = void 0;
+const SEED = 0xc3d2e1f0;
+// Workaround for missing math precision in JS.
+const MASK_HIGH = 0xffff0000;
+const MASK_LOW = 0xffff;
+class MurmurHash3_64 {
+    // todo: props
+    constructor(seed) {
+        // todo: props
+        this.h1 = null;
+        this.h2 = null;
+        this.h1 = seed ? seed & 0xffffffff : SEED;
+        this.h2 = seed ? seed & 0xffffffff : SEED;
+    }
+    update(input) {
+        let data, length;
+        if (typeof input === "string") {
+            data = new Uint8Array(input.length * 2);
+            length = 0;
+            for (let i = 0, ii = input.length; i < ii; i++) {
+                const code = input.charCodeAt(i);
+                if (code <= 0xff) {
+                    data[length++] = code;
+                }
+                else {
+                    data[length++] = code >>> 8;
+                    data[length++] = code & 0xff;
+                }
+            }
+        }
+        else if (ArrayBuffer.isView(input)) {
+            data = input.slice();
+            length = data.byteLength;
+        }
+        else {
+            throw new Error("Invalid data format, must be a string or TypedArray.");
+        }
+        const blockCounts = length >> 2;
+        const tailLength = length - blockCounts * 4;
+        // We don't care about endianness here.
+        const dataUint32 = new Uint32Array(data.buffer, 0, blockCounts);
+        let k1 = 0, k2 = 0;
+        let h1 = this.h1, h2 = this.h2;
+        const C1 = 0xcc9e2d51, C2 = 0x1b873593;
+        const C1_LOW = C1 & MASK_LOW, C2_LOW = C2 & MASK_LOW;
+        for (let i = 0; i < blockCounts; i++) {
+            if (i & 1) {
+                k1 = dataUint32[i];
+                k1 = ((k1 * C1) & MASK_HIGH) | ((k1 * C1_LOW) & MASK_LOW);
+                k1 = (k1 << 15) | (k1 >>> 17);
+                k1 = ((k1 * C2) & MASK_HIGH) | ((k1 * C2_LOW) & MASK_LOW);
+                h1 ^= k1;
+                h1 = (h1 << 13) | (h1 >>> 19);
+                h1 = h1 * 5 + 0xe6546b64;
+            }
+            else {
+                k2 = dataUint32[i];
+                k2 = ((k2 * C1) & MASK_HIGH) | ((k2 * C1_LOW) & MASK_LOW);
+                k2 = (k2 << 15) | (k2 >>> 17);
+                k2 = ((k2 * C2) & MASK_HIGH) | ((k2 * C2_LOW) & MASK_LOW);
+                h2 ^= k2;
+                h2 = (h2 << 13) | (h2 >>> 19);
+                h2 = h2 * 5 + 0xe6546b64;
+            }
+        }
+        k1 = 0;
+        switch (tailLength) {
+            case 3:
+                k1 ^= data[blockCounts * 4 + 2] << 16;
+            /* falls through */
+            case 2:
+                k1 ^= data[blockCounts * 4 + 1] << 8;
+            /* falls through */
+            case 1:
+                k1 ^= data[blockCounts * 4];
+                /* falls through */
+                k1 = ((k1 * C1) & MASK_HIGH) | ((k1 * C1_LOW) & MASK_LOW);
+                k1 = (k1 << 15) | (k1 >>> 17);
+                k1 = ((k1 * C2) & MASK_HIGH) | ((k1 * C2_LOW) & MASK_LOW);
+                if (blockCounts & 1) {
+                    h1 ^= k1;
+                }
+                else {
+                    h2 ^= k1;
+                }
+                break;
+            default: break;
+        }
+        this.h1 = h1;
+        this.h2 = h2;
+    }
+    hexdigest() {
+        let h1 = this.h1, h2 = this.h2;
+        h1 ^= h2 >>> 1;
+        h1 = ((h1 * 0xed558ccd) & MASK_HIGH) | ((h1 * 0x8ccd) & MASK_LOW);
+        h2 =
+            ((h2 * 0xff51afd7) & MASK_HIGH) |
+                (((((h2 << 16) | (h1 >>> 16)) * 0xafd7ed55) & MASK_HIGH) >>> 16);
+        h1 ^= h2 >>> 1;
+        h1 = ((h1 * 0x1a85ec53) & MASK_HIGH) | ((h1 * 0xec53) & MASK_LOW);
+        h2 =
+            ((h2 * 0xc4ceb9fe) & MASK_HIGH) |
+                (((((h2 << 16) | (h1 >>> 16)) * 0xb9fe1a85) & MASK_HIGH) >>> 16);
+        h1 ^= h2 >>> 1;
+        return ((h1 >>> 0).toString(16).padStart(8, "0") +
+            (h2 >>> 0).toString(16).padStart(8, "0"));
+    }
+}
+exports.MurmurHash3_64 = MurmurHash3_64;

package/dist/npm/annotations/shared/scripting_utils.d.ts

@@ -0,0 +1,17 @@
+declare class ColorConverters {
+    static CMYK_G([c, y, m, k]: [any, any, any, any]): (string | number)[];
+    static G_CMYK([g]: [any]): (string | number)[];
+    static G_RGB([g]: [any]): any[];
+    static G_rgb([g]: [any]): any[];
+    static G_HTML([g]: [any]): string;
+    static RGB_G([r, g, b]: [any, any, any]): (string | number)[];
+    static RGB_rgb(color: any): any;
+    static RGB_HTML(color: any): string;
+    static T_HTML(): string;
+    static T_rgb(): any[];
+    static CMYK_RGB([c, y, m, k]: [any, any, any, any]): (string | number)[];
+    static CMYK_rgb([c, y, m, k]: [any, any, any, any]): number[];
+    static CMYK_HTML(components: any): string;
+    static RGB_CMYK([r, g, b]: [any, any, any]): (string | number)[];
+}
+export { ColorConverters };

package/dist/npm/annotations/shared/scripting_utils.js

@@ -0,0 +1,93 @@
+"use strict";
+/* Copyright 2020 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorConverters = void 0;
+/**
+ * PLEASE NOTE: This file is currently imported in both the `../display/` and
+ *              `../scripting_api/` folders, hence be EXTREMELY careful about
+ *              introducing any dependencies here since that can lead to an
+ *              unexpected/unnecessary size increase of the *built* files.
+ */
+function makeColorComp(n) {
+    return Math.floor(Math.max(0, Math.min(1, n)) * 255)
+        .toString(16)
+        .padStart(2, "0");
+}
+function scaleAndClamp(x) {
+    return Math.max(0, Math.min(255, 255 * x));
+}
+// PDF specifications section 10.3
+class ColorConverters {
+    static CMYK_G([c, y, m, k]) {
+        return ["G", 1 - Math.min(1, 0.3 * c + 0.59 * m + 0.11 * y + k)];
+    }
+    static G_CMYK([g]) {
+        return ["CMYK", 0, 0, 0, 1 - g];
+    }
+    static G_RGB([g]) {
+        return ["RGB", g, g, g];
+    }
+    static G_rgb([g]) {
+        g = scaleAndClamp(g);
+        return [g, g, g];
+    }
+    static G_HTML([g]) {
+        const G = makeColorComp(g);
+        return `#${G}${G}${G}`;
+    }
+    static RGB_G([r, g, b]) {
+        return ["G", 0.3 * r + 0.59 * g + 0.11 * b];
+    }
+    static RGB_rgb(color) {
+        return color.map(scaleAndClamp);
+    }
+    static RGB_HTML(color) {
+        return `#${color.map(makeColorComp).join("")}`;
+    }
+    static T_HTML() {
+        return "#00000000";
+    }
+    static T_rgb() {
+        return [null];
+    }
+    static CMYK_RGB([c, y, m, k]) {
+        return [
+            "RGB",
+            1 - Math.min(1, c + k),
+            1 - Math.min(1, m + k),
+            1 - Math.min(1, y + k),
+        ];
+    }
+    static CMYK_rgb([c, y, m, k]) {
+        return [
+            scaleAndClamp(1 - Math.min(1, c + k)),
+            scaleAndClamp(1 - Math.min(1, m + k)),
+            scaleAndClamp(1 - Math.min(1, y + k)),
+        ];
+    }
+    static CMYK_HTML(components) {
+        const rgb = this.CMYK_RGB(components).slice(1);
+        return this.RGB_HTML(rgb);
+    }
+    static RGB_CMYK([r, g, b]) {
+        const c = 1 - r;
+        const m = 1 - g;
+        const y = 1 - b;
+        const k = Math.min(c, m, y);
+        return ["CMYK", c, m, y, k];
+    }
+}
+exports.ColorConverters = ColorConverters;

package/dist/npm/annotations/shared/ui_utils.d.ts

@@ -0,0 +1,54 @@
+declare const DEFAULT_SCALE = 1;
+declare const RenderingStates: {
+    INITIAL: number;
+    RUNNING: number;
+    PAUSED: number;
+    FINISHED: number;
+};
+declare const PresentationModeState: {
+    UNKNOWN: number;
+    NORMAL: number;
+    CHANGING: number;
+    FULLSCREEN: number;
+};
+declare const TextLayerMode: {
+    DISABLE: number;
+    ENABLE: number;
+    ENABLE_PERMISSIONS: number;
+};
+declare const ScrollMode: {
+    UNKNOWN: number;
+    VERTICAL: number;
+    HORIZONTAL: number;
+    WRAPPED: number;
+    PAGE: number;
+};
+/**
+ * Scrolls specified element into view of its parent.
+ * @param {HTMLElement} element - The element to be visible.
+ * @param {Object} [spot] - An object with optional top and left properties,
+ *   specifying the offset from the top left edge.
+ * @param {number} [spot.left]
+ * @param {number} [spot.top]
+ * @param {boolean} [scrollMatches] - When scrolling search results into view,
+ *   ignore elements that either: Contains marked content identifiers,
+ *   or have the CSS-rule `overflow: hidden;` set. The default value is `false`.
+ */
+declare function scrollIntoView(element: any, spot: any, scrollMatches?: boolean): void;
+/**
+ * Helper function to parse query string (e.g. ?param1=value&param2=...).
+ * @param {string} query
+ * @returns {Map}
+ */
+declare function parseQueryString(query: any): Map<any, any>;
+/**
+ * Use binary search to find the index of the first item in a given array which
+ * passes a given condition. The items are expected to be sorted in the sense
+ * that if the condition is true for one item in the array, then it is also true
+ * for all following items.
+ *
+ * @returns {number} Index of the first array element to pass the test,
+ *                   or |items.length| if no such element exists.
+ */
+declare function binarySearchFirstItem(items: any, condition: any, start?: number): any;
+export { binarySearchFirstItem, DEFAULT_SCALE, parseQueryString, PresentationModeState, RenderingStates, scrollIntoView, ScrollMode, TextLayerMode, };