neozipkit 0.1.1

package/dist/shared/components/CertificateOTS.d.ts

@@ -0,0 +1,15 @@
+import ZipEntry from '../ZipEntry';
+import type { AttestationValue } from '../types';
+/**
+ * Generates a certificate HTML document based on timestamp information
+ *
+ * @param attestStr - Attestation message
+ * @param zipFile - Name of the zip file
+ * @param hashDigest - Hash digest of the zip file
+ * @param needsUpdateMsg - Message indicating if update is needed
+ * @param attestationValues - Array of attestation values
+ * @param zipEntries - Array of ZipEntry objects
+ * @param narrow - Whether to use narrow layout
+ * @returns Generated HTML certificate as string
+ */
+export default function CertificateTemplate(attestStr: string | null, zipFile: string, hashDigest: string, needsUpdateMsg: string, attestationValues: AttestationValue[], zipEntries: ZipEntry[], narrow?: boolean): string;

package/dist/shared/components/CertificateOTS.js

@@ -0,0 +1,116 @@
+"use strict";
+// ======================================
+//	CertificateOTS.ts
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = CertificateTemplate;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Headers_1 = require("../constants/Headers");
+/**
+ * Generates a certificate HTML document based on timestamp information
+ *
+ * @param attestStr - Attestation message
+ * @param zipFile - Name of the zip file
+ * @param hashDigest - Hash digest of the zip file
+ * @param needsUpdateMsg - Message indicating if update is needed
+ * @param attestationValues - Array of attestation values
+ * @param zipEntries - Array of ZipEntry objects
+ * @param narrow - Whether to use narrow layout
+ * @returns Generated HTML certificate as string
+ */
+function CertificateTemplate(attestStr, zipFile, hashDigest, needsUpdateMsg, attestationValues, zipEntries, narrow) {
+    // Load the HTML template
+    let templatePath;
+    try {
+        // Try to find the template from the package root
+        templatePath = path_1.default.resolve(process.cwd(), 'assets/templates/certificate.html');
+        if (!fs_1.default.existsSync(templatePath)) {
+            // If not found in current working directory, try relative to this file
+            templatePath = path_1.default.resolve(__dirname, '../../assets/templates/certificate.html');
+        }
+        if (!fs_1.default.existsSync(templatePath)) {
+            throw new Error('Certificate template not found');
+        }
+    }
+    catch (error) {
+        console.error('Error resolving template path:', error);
+        return '';
+    }
+    // Read the template file
+    let htmlTemplate;
+    try {
+        htmlTemplate = fs_1.default.readFileSync(templatePath, 'utf8');
+    }
+    catch (error) {
+        console.error('Error reading template file:', error);
+        return '';
+    }
+    const updateWarning = needsUpdateMsg || '';
+    // Generate attestation HTML
+    let attestHTML = '';
+    if (attestationValues && attestationValues.length > 0) {
+        attestationValues.forEach((attest) => {
+            attestHTML += `
+        <div class="key-value-pair">
+          <div class="key">Block Height:</div>
+          <div class="value">${attest['blockHeight']}</div>
+        </div>
+        <div class="key-value-pair">
+          <div class="key">Transaction:</div>
+          <div class="value">${attest['transactionId']}</div>
+        </div>
+        <div class="key-value-pair">
+          <div class="key">Merkle Root:</div>
+          <div class="value">${attest['merkleRoot']}</div>
+        </div>
+        <br/>
+      `;
+        });
+    }
+    // Generate files table HTML
+    let stampEntry = null;
+    let files = [];
+    for (const entry of zipEntries) {
+        if (entry.filename === Headers_1.TIMESTAMP_METADATA) {
+            stampEntry = entry;
+        }
+        else if (entry.filename === Headers_1.TIMESTAMP_SUBMITTED) {
+            if (stampEntry == null)
+                stampEntry = entry;
+        }
+        else if (entry.sha256) {
+            let file = {
+                name: entry.filename,
+                size: entry.uncompressedSize.toString(),
+                date: entry.toFormattedUTCDateString(),
+                hash: entry.sha256,
+            };
+            files.push(file);
+        }
+    }
+    let filesTableHTML = '';
+    files.forEach((file) => {
+        filesTableHTML += `
+      <tr>
+        <td class="table-data1">${file.name}</td>
+        <td class="table-data">${file.size}</td>
+        <td class="table-data">${file.date}</td>
+        <td class="table-data">${file.hash}</td>
+      </tr>
+    `;
+    });
+    // Replace placeholders in the template
+    let html = htmlTemplate
+        .replace(/{{ATTEST_STR}}/g, attestStr || '')
+        .replace(/{{UPDATE_WARNING}}/g, needsUpdateMsg ? `<div class="warning">${needsUpdateMsg}</div>` : '')
+        .replace(/{{ZIP_FILE}}/g, zipFile)
+        .replace(/{{HASH_DIGEST}}/g, hashDigest)
+        .replace(/{{ATTESTATION_HTML}}/g, attestHTML)
+        .replace(/{{FILES_TABLE_HTML}}/g, filesTableHTML);
+    return html;
+}

package/dist/shared/components/FileSys.d.ts

@@ -0,0 +1,2 @@
+export declare function outputToFile(fileName: string, buffer: Buffer, dirPath: string, overwrite: boolean, never: boolean, fileAttr: number): boolean;
+export declare function makeDir(folder: string): void;

package/dist/shared/components/FileSys.js

@@ -0,0 +1,113 @@
+"use strict";
+// ======================================
+//	FileSys.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputToFile = outputToFile;
+exports.makeDir = makeDir;
+const fs = __importStar(require("fs"));
+const pth = __importStar(require("path"));
+const Errors_1 = __importDefault(require("../constants/Errors"));
+// Output a buffer to a file
+function outputToFile(fileName, buffer, dirPath, overwrite, never, fileAttr) {
+    // get Unix file permissions
+    const _fattr = fileAttr ? (((fileAttr >>> 0) | 0) >> 16) & 0xfff : 0;
+    const _path = dirPath ? dirPath + pth.sep + fileName : fileName;
+    if (fs.existsSync(_path)) {
+        console.log('File exists: ', _path);
+        if (never)
+            return false;
+        if (!overwrite) {
+            console.log('Overwrite file: ', _path);
+            return false; // cannot overwrite
+        }
+        const stat = fs.statSync(_path);
+        if (stat.isDirectory())
+            return false;
+    }
+    // Check if we need to create a new folder
+    const _folder = pth.dirname(_path);
+    if (!fs.existsSync(_folder)) {
+        makeDir(_folder);
+    }
+    var fd;
+    try {
+        fd = fs.openSync(_path, "w", 438); // 0666
+    }
+    catch (e) {
+        fs.chmodSync(_path, 438);
+        fd = fs.openSync(_path, "w", 438);
+    }
+    if (fd) {
+        try {
+            fs.writeSync(fd, buffer, 0, buffer.length, 0);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    if (_fattr)
+        fs.chmodSync(_path, _fattr);
+    return true;
+}
+// Make directories tree for a given path
+function makeDir(folder) {
+    console.log('mkDir: ', folder);
+    // Sync - make directories tree
+    function mkdirSync(fpath) {
+        let resolvedPath = fpath.split(pth.sep)[0];
+        fpath.split(pth.sep).forEach(function (name) {
+            if (!name || name.endsWith(":"))
+                return;
+            resolvedPath += pth.sep + name;
+            var stat;
+            try {
+                stat = fs.statSync(resolvedPath);
+            }
+            catch (e) {
+                fs.mkdirSync(resolvedPath);
+            }
+            if (stat && stat.isFile())
+                throw Errors_1.default.FILE_IN_THE_WAY.replace("%s", resolvedPath);
+        });
+    }
+    mkdirSync(folder);
+}
+;

package/dist/shared/components/HashAccumulator.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Class for accumulating and combining SHA-256 hashes using both XOR and Merkle tree methods
+ *
+ * Usage example:
+ * ```typescript
+ * const accumulator = new HashAccumulator();
+ * accumulator.addHash('a1b2c3d4');
+ * accumulator.addHash('12345678');
+ * console.log(accumulator.xorHash()); // Outputs the accumulated XOR result
+ * console.log(accumulator.merkleRoot()); // Outputs the accumulated Merkle root
+ * ```
+ */
+export default class HashAccumulator {
+    private hashes;
+    private xorResult;
+    /**
+     * Creates a new HashAccumulator instance
+     * Initializes empty hash array and zero-filled XOR buffer
+     */
+    constructor();
+    /**
+     * Adds a hash to both the XOR accumulation and hash array
+     * @param hash - Hash value as hex string or Buffer
+     * The hash must be 32 bytes (SHA-256)
+     */
+    addHash(hash: string | Buffer): void;
+    /**
+     * Gets the accumulated XOR of all added hashes
+     * @returns Hex string of XOR result
+     */
+    xorHash(): string;
+    /**
+     * Creates a Merkle tree from accumulated hashes and returns the root
+     * @returns Hex string of Merkle root, or null if no hashes added
+     */
+    merkleRoot(): string | null;
+    /**
+     * Gets the number of hashes accumulated
+     * @returns Number of accumulated hashes
+     */
+    leafCount(): number;
+    /**
+     * Resets the accumulator to initial state
+     * Clears hash array and zeroes XOR buffer
+     */
+    clear(): void;
+    /**
+     * Combines multiple hash results into a single Merkle root
+     * @param results - Array of objects containing merkleRoot properties
+     * @returns Combined Merkle root as hex string, or null if no valid roots
+     */
+    static combineResults(results: {
+        merkleRoot?: string;
+    }[]): string | null;
+}

package/dist/shared/components/HashAccumulator.js

@@ -0,0 +1,100 @@
+"use strict";
+// ======================================
+//  HashAccumulator.ts
+// ======================================
+Object.defineProperty(exports, "__esModule", { value: true });
+const merkleTree_1 = require("./merkleTree");
+/**
+ * Class for accumulating and combining SHA-256 hashes using both XOR and Merkle tree methods
+ *
+ * Usage example:
+ * ```typescript
+ * const accumulator = new HashAccumulator();
+ * accumulator.addHash('a1b2c3d4');
+ * accumulator.addHash('12345678');
+ * console.log(accumulator.xorHash()); // Outputs the accumulated XOR result
+ * console.log(accumulator.merkleRoot()); // Outputs the accumulated Merkle root
+ * ```
+ */
+class HashAccumulator {
+    /**
+     * Creates a new HashAccumulator instance
+     * Initializes empty hash array and zero-filled XOR buffer
+     */
+    constructor() {
+        this.hashes = [];
+        this.xorResult = Buffer.alloc(32, 0);
+    }
+    /**
+     * Adds a hash to both the XOR accumulation and hash array
+     * @param hash - Hash value as hex string or Buffer
+     * The hash must be 32 bytes (SHA-256)
+     */
+    addHash(hash) {
+        // Convert hash to Buffer if it's a string
+        const hashBuffer = typeof hash === 'string'
+            ? Buffer.from(hash, 'hex')
+            : hash;
+        // Add to array for Merkle tree
+        this.hashes.push(hashBuffer);
+        // XOR accumulation
+        for (let i = 0; i < 32; i++) {
+            this.xorResult[i] ^= hashBuffer[i];
+        }
+    }
+    /**
+     * Gets the accumulated XOR of all added hashes
+     * @returns Hex string of XOR result
+     */
+    xorHash() {
+        return this.xorResult.toString('hex');
+    }
+    /**
+     * Creates a Merkle tree from accumulated hashes and returns the root
+     * @returns Hex string of Merkle root, or null if no hashes added
+     */
+    merkleRoot() {
+        let merkleRoot = null;
+        if (this.hashes.length > 0) {
+            const tree = new merkleTree_1.MerkleTree(this.hashes, {
+                hashLeaves: false, // Leaves are already hashed
+                sortLeaves: true, // Sort leaves for consistent results
+                sortPairs: true, // Sort pairs for consistent results
+                duplicateOdd: true // Duplicate odd leaf for balanced tree
+            });
+            merkleRoot = tree.getRoot().toString('hex');
+        }
+        return merkleRoot;
+    }
+    /**
+     * Gets the number of hashes accumulated
+     * @returns Number of accumulated hashes
+     */
+    leafCount() {
+        return this.hashes.length;
+    }
+    /**
+     * Resets the accumulator to initial state
+     * Clears hash array and zeroes XOR buffer
+     */
+    clear() {
+        this.hashes = [];
+        this.xorResult = Buffer.alloc(32, 0);
+    }
+    /**
+     * Combines multiple hash results into a single Merkle root
+     * @param results - Array of objects containing merkleRoot properties
+     * @returns Combined Merkle root as hex string, or null if no valid roots
+     */
+    static combineResults(results) {
+        const accumulator = new HashAccumulator();
+        // Combine all hashes
+        for (const result of results) {
+            if (result.merkleRoot) {
+                accumulator.addHash(result.merkleRoot);
+            }
+        }
+        return accumulator.merkleRoot();
+    }
+}
+exports.default = HashAccumulator;

package/dist/shared/components/Support.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Platform and environment feature detection utility
+ * Provides boolean flags indicating support for various features needed by NeoZip
+ *
+ * @namespace Support
+ * @property {boolean} base64 - Always true, indicates base64 encoding support
+ * @property {boolean} array - Always true, indicates Array support
+ * @property {boolean} string - Always true, indicates String support
+ * @property {boolean} isNode - True if running in Node.js environment
+ * @property {boolean} buffer - True if Node.js Buffer is available
+ * @property {boolean} uint8array - True if Uint8Array is supported
+ * @property {boolean} arrayBuffer - True if both ArrayBuffer and Uint8Array are supported
+ * @property {boolean} blob - True if Blob creation with ArrayBuffer is supported
+ * @property {boolean} streams - True if ReadableStream and WritableStream are supported
+ * @property {boolean} fileReader - True if FileReader is supported
+ */
+declare const Support: {
+    /** Base64 encoding support (always true) */
+    base64: boolean;
+    /** Array support (always true) */
+    array: boolean;
+    /** String support (always true) */
+    string: boolean;
+    /**
+     * Detects if code is running in Node.js environment
+     * True if process.versions.node exists, undefined in browser
+     */
+    isNode: boolean;
+    /**
+     * Detects if Node.js Buffer is available
+     * True in Node.js, undefined in browser
+     */
+    buffer: boolean;
+    /**
+     * Detects support for Uint8Array typed array
+     * Used for binary data handling
+     */
+    uint8array: boolean;
+    /**
+     * Detects support for both ArrayBuffer and Uint8Array
+     * Required for binary data operations
+     */
+    arrayBuffer: boolean;
+    /**
+     * Detects support for Blob with ArrayBuffer
+     * Tests by attempting to create an empty ZIP Blob
+     * @returns {boolean} True if Blob creation succeeds
+     */
+    blob: boolean;
+    /**
+     * Detects support for Streams API
+     * Checks for ReadableStream/WritableStream in browser
+     * or 'stream' module in Node.js
+     * @returns {boolean} True if streams are supported in current environment
+     */
+    streams: boolean;
+    /**
+     * Detects support for FileReader
+     * @returns {boolean} True if FileReader is supported
+     */
+    fileReader: boolean;
+};
+export default Support;

package/dist/shared/components/Support.js

@@ -0,0 +1,70 @@
+"use strict";
+// ======================================
+//	Support.ts
+//  A utility module for detecting platform capabilities and features
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Platform and environment feature detection utility
+ * Provides boolean flags indicating support for various features needed by NeoZip
+ *
+ * @namespace Support
+ * @property {boolean} base64 - Always true, indicates base64 encoding support
+ * @property {boolean} array - Always true, indicates Array support
+ * @property {boolean} string - Always true, indicates String support
+ * @property {boolean} isNode - True if running in Node.js environment
+ * @property {boolean} buffer - True if Node.js Buffer is available
+ * @property {boolean} uint8array - True if Uint8Array is supported
+ * @property {boolean} arrayBuffer - True if both ArrayBuffer and Uint8Array are supported
+ * @property {boolean} blob - True if Blob creation with ArrayBuffer is supported
+ * @property {boolean} streams - True if ReadableStream and WritableStream are supported
+ * @property {boolean} fileReader - True if FileReader is supported
+ */
+const Support = {
+    /** Base64 encoding support (always true) */
+    base64: true,
+    /** Array support (always true) */
+    array: true,
+    /** String support (always true) */
+    string: true,
+    /**
+     * Detects if code is running in Node.js environment
+     * True if process.versions.node exists, undefined in browser
+     */
+    isNode: true,
+    /**
+     * Detects if Node.js Buffer is available
+     * True in Node.js, undefined in browser
+     */
+    buffer: true,
+    /**
+     * Detects support for Uint8Array typed array
+     * Used for binary data handling
+     */
+    uint8array: true,
+    /**
+     * Detects support for both ArrayBuffer and Uint8Array
+     * Required for binary data operations
+     */
+    arrayBuffer: typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined",
+    /**
+     * Detects support for Blob with ArrayBuffer
+     * Tests by attempting to create an empty ZIP Blob
+     * @returns {boolean} True if Blob creation succeeds
+     */
+    blob: true,
+    /**
+     * Detects support for Streams API
+     * Checks for ReadableStream/WritableStream in browser
+     * or 'stream' module in Node.js
+     * @returns {boolean} True if streams are supported in current environment
+     */
+    streams: true,
+    /**
+     * Detects support for FileReader
+     * @returns {boolean} True if FileReader is supported
+     */
+    fileReader: false
+};
+exports.default = Support;

package/dist/shared/components/Util.d.ts

@@ -0,0 +1,21 @@
+export declare const DATATYPE: {
+    STRING: string;
+    BUFFER: string;
+    ARRAY: string;
+    ARRAYBUFFER: string;
+    U8ARRAY: string;
+    BLOB: string;
+    STREAM: string;
+};
+export declare const crc32update: (pCrc32: number, bval: number) => number;
+export declare function crc32(buf: Buffer): number;
+export declare function readBigUInt64LE(buffer: Buffer, index: number): number;
+export declare const uMul: (a: number, b: number) => number;
+interface StreamLike {
+    on: Function;
+    pause: Function;
+    resume: Function;
+}
+export declare function isStream(obj: unknown): obj is StreamLike;
+export declare function getTypeOf(input: string | Buffer | Blob | Array<any> | ArrayBuffer | Uint8Array): string;
+export {};

package/dist/shared/components/Util.js

@@ -0,0 +1,115 @@
+"use strict";
+// ======================================
+//	Util.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+// Utility functions
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uMul = exports.crc32update = exports.DATATYPE = void 0;
+exports.crc32 = crc32;
+exports.readBigUInt64LE = readBigUInt64LE;
+exports.isStream = isStream;
+exports.getTypeOf = getTypeOf;
+const Support_1 = __importDefault(require("./Support"));
+const Errors_1 = __importDefault(require("../constants/Errors"));
+exports.DATATYPE = {
+    STRING: "string",
+    BUFFER: "buffer",
+    ARRAY: "array",
+    ARRAYBUFFER: "arraybuffer",
+    U8ARRAY: "uint8array",
+    BLOB: "blob",
+    STREAM: "stream",
+};
+// Generate the CRC32 table
+const crcTable = new Uint32Array(256).map((t, crc) => {
+    for (let j = 0; j < 8; j++) {
+        if (0 !== (crc & 1)) {
+            crc = (crc >>> 1) ^ 0xedb88320;
+        }
+        else {
+            crc >>>= 1;
+        }
+    }
+    return crc >>> 0;
+});
+// crc32 byte single update (actually same function is part of utils.crc32 function :) )
+const crc32update = (pCrc32, bval) => {
+    return crcTable[(pCrc32 ^ bval) & 0xff] ^ (pCrc32 >>> 8);
+};
+exports.crc32update = crc32update;
+// Return the CRC32 of a buffer
+function crc32(buf) {
+    if (typeof buf === "string") {
+        buf = Buffer.from(buf, "utf8");
+    }
+    // Generate crcTable
+    // if (!crcTable.length) genCRCTable();
+    let len = buf.length;
+    let crc = ~0;
+    for (let off = 0; off < len;)
+        crc = crcTable[(crc ^ buf[off++]) & 0xff] ^ (crc >>> 8);
+    // xor and cast as uint32 number
+    return ~crc >>> 0;
+}
+;
+// Parse a 64-bit unsigned integer from a buffer
+function readBigUInt64LE(buffer, index) {
+    var buf = Buffer.from(buffer.subarray(index, index + 8));
+    buf.swap64();
+    return parseInt(`0x${buf.toString("hex")}`);
+}
+;
+// C-style uInt32 Multiply (discards higher bits, when JS multiply discards lower bits)
+const uMul = (a, b) => Math.imul(a, b) >>> 0;
+exports.uMul = uMul;
+function isStream(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const streamLike = obj;
+    return typeof streamLike.on === "function" &&
+        typeof streamLike.pause === "function" &&
+        typeof streamLike.resume === "function";
+}
+// Return the type of the input.
+// The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
+// If the type is not supported, throw an exception.
+function getTypeOf(input) {
+    if (typeof input === "string") {
+        if (!Support_1.default.string)
+            throw new Error(Errors_1.default.DATATYPE_STRING_UNSUPPORTED);
+        return exports.DATATYPE.STRING;
+    }
+    else if (Object.prototype.toString.call(input) === "[object Array]") {
+        if (!Support_1.default.array)
+            throw new Error(Errors_1.default.DATATYPE_ARRAY_UNSUPPORTED);
+        return exports.DATATYPE.ARRAY;
+    }
+    else if (Buffer.isBuffer(input)) {
+        if (!Support_1.default.buffer)
+            throw new Error(Errors_1.default.DATATYPE_BUFFER_UNSUPPORTED);
+        return exports.DATATYPE.BUFFER;
+    }
+    else if (input instanceof Blob) {
+        if (!Support_1.default.blob)
+            throw new Error(Errors_1.default.DATATYPE_BLOB_UNSUPPORTED);
+        return exports.DATATYPE.BLOB;
+    }
+    else if (input instanceof Uint8Array) {
+        if (!Support_1.default.uint8array)
+            throw new Error(Errors_1.default.DATATYPE_U8ARRAY_UNSUPPORTED);
+        return exports.DATATYPE.U8ARRAY;
+    }
+    else if (input instanceof ArrayBuffer) {
+        if (!Support_1.default.arrayBuffer)
+            throw new Error(Errors_1.default.DATATYPE_ARRAYBUFFER_UNSUPPORTED);
+        return exports.DATATYPE.ARRAYBUFFER;
+    }
+    else { // Add an else block to handle unsupported types
+        throw new Error(Errors_1.default.DATATYPE_UNSUPPORTED);
+    }
+}
+;

package/dist/shared/components/ZipCrypto.d.ts

@@ -0,0 +1,3 @@
+export declare function sha256(data: Buffer): string;
+export declare function encrypter(data: Buffer | null, checkByte: number, pwd: string): Buffer | null;
+export declare function decrypter(pwd: string | Buffer): Function;