@loaders.gl/crypto 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/crypto-hash.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoHash = void 0;
+const hash_1 = require("./hash");
+let CryptoJS;
+/**
+ * A transform that calculates Cryptographic Hash using Crypto JS library
+ * @deprecated Warning, experimental class
+ */
+class CryptoHash extends hash_1.Hash {
+    constructor(options) {
+        super();
+        this.options = options;
+        this._algorithm = this.options?.crypto?.algorithm;
+        if (!this._algorithm) {
+            throw new Error(this.name);
+        }
+        this.name = this._algorithm.toLowerCase();
+    }
+    async preload() {
+        if (!CryptoJS) {
+            CryptoJS = this.options?.modules?.CryptoJS;
+            if (!CryptoJS) {
+                throw new Error(this.name);
+            }
+        }
+        if (!this._hash) {
+            const algo = CryptoJS.algo[this._algorithm];
+            this._hash = algo.create();
+        }
+        if (!this._hash) {
+            throw new Error(this.name);
+        }
+    }
+    /**
+     * Atomic hash calculation
+     * @returns base64 encoded hash
+     */
+    async hash(input) {
+        await this.preload();
+        // arrayBuffer is accepted, even though types and docs say no
+        // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer
+        // @ts-expect-error
+        const typedWordArray = CryptoJS.lib.WordArray.create(input);
+        return this._hash.update(typedWordArray).finalize().toString(CryptoJS.enc.Base64);
+    }
+    async *hashBatches(asyncIterator) {
+        await this.preload();
+        for await (const chunk of asyncIterator) {
+            // arrayBuffer is accepted, even though types and docs say no
+            // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer
+            // @ts-expect-error
+            const typedWordArray = CryptoJS.lib.WordArray.create(chunk);
+            this._hash.update(typedWordArray);
+            yield chunk;
+        }
+        const hash = this._hash.finalize().toString(CryptoJS.enc.Base64);
+        this.options?.crypto?.onEnd?.({ hash });
+    }
+}
+exports.CryptoHash = CryptoHash;

package/dist/lib/hash.d.ts

@@ -0,0 +1,22 @@
+declare type HashOptions = {
+    modules?: {
+        [moduleName: string]: any;
+    };
+    crypto?: {
+        onEnd?: (result: {
+            hash: string;
+        }) => any;
+    };
+};
+/** Abstract hash base class */
+export declare abstract class Hash {
+    abstract readonly name: string;
+    abstract readonly options: HashOptions;
+    constructor(options?: HashOptions);
+    preload(): Promise<void>;
+    abstract hash(arrayBuffer: ArrayBuffer): Promise<string>;
+    hashBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>): AsyncIterable<ArrayBuffer>;
+    protected concatenate(asyncIterator: any): Promise<ArrayBuffer>;
+}
+export {};
+//# sourceMappingURL=hash.d.ts.map

package/dist/lib/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/lib/hash.ts"],"names":[],"mappings":"AAGA,aAAK,WAAW,GAAG;IACjB,OAAO,CAAC,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IACtC,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,KAAK,GAAG,CAAC;KACzC,CAAC;CACH,CAAC;AAEF,+BAA+B;AAC/B,8BAAsB,IAAI;IACxB,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;gBAE3B,OAAO,GAAE,WAAgB;IAI/B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAEjD,WAAW,CAChB,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,GAChE,aAAa,CAAC,WAAW,CAAC;cAab,WAAW,CAAC,aAAa,KAAA,GAAG,OAAO,CAAC,WAAW,CAAC;CAGjE"}

package/dist/lib/hash.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hash = void 0;
+// Hash
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+/** Abstract hash base class */
+class Hash {
+    constructor(options = {}) {
+        this.hashBatches = this.hashBatches.bind(this);
+    }
+    async preload() {
+        return;
+    }
+    async *hashBatches(asyncIterator) {
+        const arrayBuffers = [];
+        for await (const arrayBuffer of asyncIterator) {
+            arrayBuffers.push(arrayBuffer);
+            yield arrayBuffer;
+        }
+        const output = await this.concatenate(arrayBuffers);
+        const hash = await this.hash(output);
+        this.options?.crypto?.onEnd?.({ hash });
+    }
+    // HELPERS
+    async concatenate(asyncIterator) {
+        return await (0, loader_utils_1.concatenateArrayBuffersAsync)(asyncIterator);
+    }
+}
+exports.Hash = Hash;

package/dist/lib/md5-hash.d.ts

@@ -0,0 +1,15 @@
+import { Hash } from './hash';
+/**
+ * A transform that calculates MD5 hashes, passing data through
+ */
+export declare class MD5Hash extends Hash {
+    readonly name = "md5";
+    readonly options: any;
+    constructor(options?: {});
+    /**
+     * Atomic hash calculation
+     * @returns base64 encoded hash
+     */
+    hash(input: ArrayBuffer): Promise<string>;
+}
+//# sourceMappingURL=md5-hash.d.ts.map

package/dist/lib/md5-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5-hash.d.ts","sourceRoot":"","sources":["../../src/lib/md5-hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAC;AAI5B;;GAEG;AACH,qBAAa,OAAQ,SAAQ,IAAI;IAC/B,QAAQ,CAAC,IAAI,SAAS;IACtB,QAAQ,CAAC,OAAO,MAAC;gBAEL,OAAO,KAAK;IAKxB;;;OAGG;IACG,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;CAQhD"}

package/dist/lib/md5-hash.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MD5Hash = void 0;
+// Fork of https://github.com/briantbutton/md5-wasm under MIT license
+const hash_1 = require("./hash");
+const md5_wasm_1 = __importDefault(require("./algorithms/md5-wasm"));
+const digest_utils_1 = require("./utils/digest-utils");
+/**
+ * A transform that calculates MD5 hashes, passing data through
+ */
+class MD5Hash extends hash_1.Hash {
+    constructor(options = {}) {
+        super();
+        this.name = 'md5';
+        this.options = options;
+    }
+    /**
+     * Atomic hash calculation
+     * @returns base64 encoded hash
+     */
+    async hash(input) {
+        const md5Promise = new Promise((resolve, reject) => 
+        // @ts-expect-error
+        (0, md5_wasm_1.default)(input).then(resolve).catch(reject));
+        const hex = await md5Promise;
+        return (0, digest_utils_1.hexToBase64)(hex);
+    }
+}
+exports.MD5Hash = MD5Hash;

package/dist/lib/node-hash.d.ts

@@ -0,0 +1,28 @@
+import { Hash } from './hash';
+declare type CryptoHashOptions = {
+    crypto: {
+        algorithm: string;
+        onEnd?: (result: {
+            hash: string;
+        }) => any;
+    };
+};
+/**
+ * Calculates Cryptographic Hash using Node.js crypto library
+ * @deprecated Warning, experimental class
+ */
+export declare class NodeHash extends Hash {
+    readonly name = "crypto-node";
+    options: CryptoHashOptions;
+    private _algorithm;
+    private _hash;
+    constructor(options: CryptoHashOptions);
+    /**
+     * Atomic hash calculation
+     * @returns base64 encoded hash
+     */
+    hash(input: ArrayBuffer): Promise<string>;
+    hashBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>): AsyncIterable<ArrayBuffer>;
+}
+export {};
+//# sourceMappingURL=node-hash.d.ts.map

package/dist/lib/node-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-hash.d.ts","sourceRoot":"","sources":["../../src/lib/node-hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAC;AAG5B,aAAK,iBAAiB,GAAG;IACvB,MAAM,EAAE;QACN,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,KAAK,GAAG,CAAC;KACzC,CAAC;CACH,CAAC;AAEF;;;GAGG;AACH,qBAAa,QAAS,SAAQ,IAAI;IAChC,QAAQ,CAAC,IAAI,iBAAiB;IAE9B,OAAO,EAAE,iBAAiB,CAAC;IAE3B,OAAO,CAAC,UAAU,CAAC;IAEnB,OAAO,CAAC,KAAK,CAAC;gBAEF,OAAO,EAAE,iBAAiB;IAQtC;;;OAGG;IACG,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAOxC,WAAW,CAChB,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,GAChE,aAAa,CAAC,WAAW,CAAC;CAW9B"}

package/dist/lib/node-hash.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeHash = void 0;
+// This dependency is too big, application must provide it
+const hash_1 = require("./hash");
+const crypto_1 = require("crypto"); // Node.js builtin
+/**
+ * Calculates Cryptographic Hash using Node.js crypto library
+ * @deprecated Warning, experimental class
+ */
+class NodeHash extends hash_1.Hash {
+    constructor(options) {
+        super();
+        this.name = 'crypto-node';
+        this.options = options;
+        if (!this.options?.crypto?.algorithm) {
+            throw new Error(this.name);
+        }
+    }
+    /**
+     * Atomic hash calculation
+     * @returns base64 encoded hash
+     */
+    async hash(input) {
+        await this.preload();
+        const hash = (0, crypto_1.createHash)(this.options?.crypto?.algorithm?.toLowerCase());
+        const inputArray = new Uint8Array(input);
+        return hash.update(inputArray).digest('base64');
+    }
+    async *hashBatches(asyncIterator) {
+        await this.preload();
+        const hash = (0, crypto_1.createHash)(this.options?.crypto?.algorithm?.toLowerCase());
+        for await (const chunk of asyncIterator) {
+            // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer
+            const inputArray = new Uint8Array(chunk);
+            hash.update(inputArray);
+            yield chunk;
+        }
+        this.options?.crypto?.onEnd?.({ hash: hash.digest('base64') });
+    }
+}
+exports.NodeHash = NodeHash;

package/dist/lib/sha256-hash.d.ts

@@ -0,0 +1,19 @@
+import { CryptoHash } from './crypto-hash';
+declare type CryptoHashOptions = {
+    modules: {
+        [moduleName: string]: any;
+    };
+    crypto?: {
+        onEnd?: (result: {
+            hash: string;
+        }) => any;
+    };
+};
+/**
+ * A transform that calculates Cryptographic Hash
+ */
+export declare class SHA256Hash extends CryptoHash {
+    constructor(options: CryptoHashOptions);
+}
+export {};
+//# sourceMappingURL=sha256-hash.d.ts.map

package/dist/lib/sha256-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256-hash.d.ts","sourceRoot":"","sources":["../../src/lib/sha256-hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC,aAAK,iBAAiB,GAAG;IACvB,OAAO,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IACrC,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,KAAK,GAAG,CAAC;KACzC,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,qBAAa,UAAW,SAAQ,UAAU;gBAC5B,OAAO,EAAE,iBAAiB;CAGvC"}

package/dist/lib/sha256-hash.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHA256Hash = void 0;
+//
+const crypto_hash_1 = require("./crypto-hash");
+/**
+ * A transform that calculates Cryptographic Hash
+ */
+class SHA256Hash extends crypto_hash_1.CryptoHash {
+    constructor(options) {
+        super({ ...options, crypto: { ...options.crypto, algorithm: 'SHA256' } });
+    }
+}
+exports.SHA256Hash = SHA256Hash;

package/dist/lib/utils/base64-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `btoa()` polyfill as defined by the HTML and Infra specs, which mostly just references
+ * RFC 4648.
+ */
+export declare function toBase64(string: string): string | null;
+//# sourceMappingURL=base64-utils.d.ts.map

package/dist/lib/utils/base64-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/base64-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkCtD"}

package/dist/lib/utils/base64-utils.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = void 0;
+/**
+ * `btoa()` polyfill as defined by the HTML and Infra specs, which mostly just references
+ * RFC 4648.
+ */
+function toBase64(string) {
+    // String conversion as required by Web IDL.
+    string = `${string}`;
+    // "The btoa() method must throw an "InvalidCharacterError" DOMException if
+    // data contains any character whose code point is greater than U+00FF."
+    for (let i = 0; i < string.length; i++) {
+        if (string.charCodeAt(i) > 255) {
+            return null;
+        }
+    }
+    let out = '';
+    for (let i = 0; i < string.length; i += 3) {
+        /** @type {Array[4]} */
+        const groupsOfSix = [undefined, undefined, undefined, undefined];
+        groupsOfSix[0] = string.charCodeAt(i) >> 2;
+        groupsOfSix[1] = (string.charCodeAt(i) & 0x03) << 4;
+        if (string.length > i + 1) {
+            groupsOfSix[1] |= string.charCodeAt(i + 1) >> 4;
+            groupsOfSix[2] = (string.charCodeAt(i + 1) & 0x0f) << 2;
+        }
+        if (string.length > i + 2) {
+            // @ts-expect-error
+            groupsOfSix[2] |= string.charCodeAt(i + 2) >> 6;
+            groupsOfSix[3] = string.charCodeAt(i + 2) & 0x3f;
+        }
+        for (let j = 0; j < groupsOfSix.length; j++) {
+            if (typeof groupsOfSix[j] === 'undefined') {
+                out += '=';
+            }
+            else {
+                out += btoaLookup(groupsOfSix[j]);
+            }
+        }
+    }
+    return out;
+}
+exports.toBase64 = toBase64;
+/**
+ * Lookup table for btoa(), which converts a six-bit number into the
+ * corresponding ASCII character.
+ */
+function btoaLookup(idx) {
+    if (idx < 26) {
+        return String.fromCharCode(idx + 'A'.charCodeAt(0));
+    }
+    if (idx < 52) {
+        return String.fromCharCode(idx - 26 + 'a'.charCodeAt(0));
+    }
+    if (idx < 62) {
+        return String.fromCharCode(idx - 52 + '0'.charCodeAt(0));
+    }
+    if (idx === 62) {
+        return '+';
+    }
+    if (idx === 63) {
+        return '/';
+    }
+    // Throw INVALID_CHARACTER_ERR exception here -- won't be hit in the teststring.
+    return undefined;
+}

package/dist/lib/utils/digest-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ */
+export declare function toHex(cipher: number): string;
+/**
+ * @see https://stackoverflow.com/questions/23190056/hex-to-base64-converter-for-javascript
+ */
+export declare function hexToBase64(hexstring: string): string;
+//# sourceMappingURL=digest-utils.d.ts.map

package/dist/lib/utils/digest-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"digest-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/digest-utils.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAG5C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAUrD"}

package/dist/lib/utils/digest-utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToBase64 = exports.toHex = void 0;
+const base64_utils_1 = require("./base64-utils");
+/**
+ *
+ */
+function toHex(cipher) {
+    const hexString = cipher.toString(16);
+    return hexString === '0' ? `0${hexString}` : hexString;
+}
+exports.toHex = toHex;
+/**
+ * @see https://stackoverflow.com/questions/23190056/hex-to-base64-converter-for-javascript
+ */
+function hexToBase64(hexstring) {
+    // Add leading zero to keep even count of digits
+    // eg. f85d741 => 0f85d741
+    if (hexstring.length % 2 !== 0) {
+        hexstring = `0${hexstring}`;
+    }
+    const matches = hexstring.match(/\w{2}/g) || [];
+    const string = matches.map((a) => String.fromCharCode(parseInt(a, 16))).join('');
+    // TODO - define how to handle failures
+    return (0, base64_utils_1.toBase64)(string) || '';
+}
+exports.hexToBase64 = hexToBase64;

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export declare type CryptoHashOptions = {
+    modules?: {
+        [moduleName: string]: any;
+    };
+    crypto?: {
+        algorithm: any;
+        onEnd?: any;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IACtC,MAAM,CAAC,EAAE;QACP,SAAS,MAAC;QACV,KAAK,CAAC,MAAC;KACR,CAAC;CACH,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });