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

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

@@ -0,0 +1,213 @@
+/* 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;
+import { __classPrivateFieldGet } from "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 = __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 = __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 = __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;
+            }
+        }
+    }
+}
+_EventBus_listeners = new WeakMap();
+// /**
+//  * NOTE: Only used in the Firefox build-in pdf viewer.
+//  */
+// class FirefoxEventBus extends EventBus {
+//     #externalServices;
+//     #globalEventNames;
+//     #isInAutomation;
+//     constructor(globalEventNames, externalServices, isInAutomation) {
+//         super();
+//         this.#globalEventNames = globalEventNames;
+//         this.#externalServices = externalServices;
+//         this.#isInAutomation = isInAutomation;
+//     }
+//     dispatch(eventName, data) {
+//         if (typeof PDFJSDev !== "undefined" && !PDFJSDev.test("MOZCENTRAL")) {
+//             throw new Error("Not implemented: FirefoxEventBus.dispatch");
+//         }
+//         super.dispatch(eventName, data);
+//         if (this.#isInAutomation) {
+//             const detail = Object.create(null);
+//             if (data) {
+//                 for (const key in data) {
+//                     const value = data[key];
+//                     if (key === "source") {
+//                         if (value === window || value === document) {
+//                             return; // No need to re-dispatch (already) global events.
+//                         }
+//                         continue; // Ignore the `source` property.
+//                     }
+//                     detail[key] = value;
+//                 }
+//             }
+//             const event = new CustomEvent(eventName, {
+//                 bubbles: true,
+//                 cancelable: true,
+//                 detail,
+//             });
+//             document.dispatchEvent(event);
+//         }
+//         if (this.#globalEventNames?.has(eventName)) {
+//             this.#externalServices.dispatchGlobalEvent({
+//                 eventName,
+//                 detail: data,
+//             });
+//         }
+//     }
+// }
+export { EventBus,
+// FirefoxEventBus,
+// waitOnEventOrTimeout,
+// WaitOnType
+ };

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

@@ -0,0 +1,126 @@
+/* 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.
+ */
+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"));
+    }
+}
+export { MurmurHash3_64 };

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

@@ -0,0 +1,90 @@
+/* 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.
+ */
+/**
+ * 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];
+    }
+}
+export { ColorConverters };