@wener/utils 1.1.51 → 1.1.54

package/lib/io/ArrayBuffers.js

@@ -1,18 +1,39 @@
-import { classOf } from '../langs/classOf.js';
-import { getGlobalThis } from '../web/getGlobalThis.js';
-import { decodeBase64ToUint8Array, encodeArrayBufferToBase64 } from './base64.js';
-import { isBuffer } from './isBuffer.js';
-export var ArrayBuffers;
-(function(ArrayBuffers) {
-    let nativeBufferAllowed = true;
-    let isBufferAvailable;
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+import { classOf } from "../langs/classOf.js";
+import { getGlobalThis } from "../web/getGlobalThis.js";
+import { decodeBase64ToUint8Array, encodeArrayBufferToBase64 } from "./base64.js";
+import { isBuffer } from "./isBuffer.js";
+(function (ArrayBuffers) {
+    var nativeBufferAllowed = true;
+    var isBufferAvailable;
+    var textEncoder;
+    var textDecoder;
+    function decode(v) {
+        // need icu full data
+        // if (encoding) return new TextDecoder(encoding).decode(v);
+        return (textDecoder || (textDecoder = new TextDecoder())).decode(v);
+    }
+    function encode(v) {
+        if (typeof v === "string") {
+            return (textEncoder || (textEncoder = new TextEncoder())).encode(v);
+        }
+        return v;
+    }
     function isNativeBufferAvailable() {
+        var _getGlobalThis_Buffer_isPollyfill, _getGlobalThis_Buffer;
         // eslint-disable-next-line no-return-assign
-        return isBufferAvailable ??= !getGlobalThis().Buffer?.isPollyfill?.();
+        return isBufferAvailable !== null && isBufferAvailable !== void 0 ? isBufferAvailable : isBufferAvailable = !((_getGlobalThis_Buffer = getGlobalThis().Buffer) === null || _getGlobalThis_Buffer === void 0 ? void 0 : (_getGlobalThis_Buffer_isPollyfill = _getGlobalThis_Buffer.isPollyfill) === null || _getGlobalThis_Buffer_isPollyfill === void 0 ? void 0 : _getGlobalThis_Buffer_isPollyfill.call(_getGlobalThis_Buffer));
     }
     /**
-   * isNativeBufferAvailable check if the native {@link Buffer} is available
-   */ ArrayBuffers.isNativeBufferAvailable = isNativeBufferAvailable;
+     * isNativeBufferAvailable check if the native {@link Buffer} is available
+     */ ArrayBuffers.isNativeBufferAvailable = isNativeBufferAvailable;
     function isNativeBufferAllowed() {
         return Boolean(nativeBufferAllowed && isBufferAvailable);
     }
@@ -22,11 +43,9 @@ export var ArrayBuffers;
     }
     ArrayBuffers.setNativeBufferAllowed = setNativeBufferAllowed;
     function isArrayBuffer(v) {
-        return v instanceof ArrayBuffer;
+        return _instanceof(v, ArrayBuffer);
     }
-    /**
-   * isArrayBuffer check if the given value is an {@link ArrayBuffer}
-   */ ArrayBuffers.isArrayBuffer = isArrayBuffer;
+    ArrayBuffers.isArrayBuffer = isArrayBuffer;
     function slice(o, start, end) {
         // NodeJS Buffer slice is not the same as UInt8Array slice
         // https://nodejs.org/api/buffer.html#bufslicestart-end
@@ -36,12 +55,12 @@ export var ArrayBuffers;
         return o.slice(start, end);
     }
     /**
-   * slice the given view with the given offset and length, will handle the {@link Buffer} as well
-   *
-   * @see {@link https://nodejs.org/api/buffer.html#bufslicestart-end Buffer.slice}
-   */ ArrayBuffers.slice = slice;
+     * slice the given view with the given offset and length, will handle the {@link Buffer} as well
+     *
+     * @see {@link https://nodejs.org/api/buffer.html#bufslicestart-end Buffer.slice}
+     */ ArrayBuffers.slice = slice;
     function asView(TypedArray, v, byteOffset, byteLength) {
-        if (v instanceof TypedArray && (byteOffset ?? 0) === 0 && byteLength === undefined) {
+        if (_instanceof(v, TypedArray) && (byteOffset !== null && byteOffset !== void 0 ? byteOffset : 0) === 0 && byteLength === undefined) {
             return v;
         }
         if (ArrayBuffer.isView(v) || isBuffer(v)) {
@@ -49,95 +68,86 @@ export var ArrayBuffers;
                 // new Buffer() is deprecated
                 return Buffer.from(v.buffer, byteOffset, byteLength);
             }
-            return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength);
+            return new TypedArray(v.buffer, v.byteOffset + (byteOffset !== null && byteOffset !== void 0 ? byteOffset : 0), byteLength !== null && byteLength !== void 0 ? byteLength : v.byteLength);
         }
         return new TypedArray(v, byteOffset, byteLength);
     }
     /**
-   * asView convert the given value to given {@link TypedArray} view
-   *
-   * TypedArray can be {@link Buffer}, will avoid copy
-   */ ArrayBuffers.asView = asView;
-    function toString(source, encoding = 'utf8') {
-        // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'
-        if (typeof source === 'string') {
-            switch(encoding){
-                case 'base64':
+     * asView convert the given value to given {@link TypedArray} view
+     *
+     * TypedArray can be {@link Buffer}, will avoid copy
+     */ ArrayBuffers.asView = asView;
+    function toString(source) {
+        var encoding = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "utf8";
+        if (typeof source === "string") {
+            switch (encoding) {
+                case "base64":
                     return btoa(source);
-                case 'utf-8':
-                case 'utf8':
+                case "utf-8":
+                case "utf8":
                     return source;
                 default:
-                    throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);
+                    throw new Error("[ArrayBuffers.toString] Unsupported encoding for string: ".concat(encoding));
             }
         }
-        let u8 = asView(Uint8Array, source);
+        var u8 = asView(Uint8Array, source);
         if (isNativeBufferAllowed()) {
             return Buffer.from(u8).toString(encoding);
         }
-        // reference
-        // https://github.com/feross/buffer/blob/master/index.js
-        switch(encoding){
-            case 'hex':
+        // reference: https://github.com/feross/buffer/blob/master/index.js
+        switch (encoding) {
+            case "hex":
                 {
-                    return [
-                        ...u8
-                    ].map((b)=>hexLookupTable[b]).join('');
+                    return toHexString(u8);
                 }
-            case 'base64':
+            case "base64":
                 {
-                    return encodeArrayBufferToBase64(u8);
+                    return toBase64(u8);
                 }
-            case 'utf8':
-            // falls through
-            case 'utf-8':
-                return new TextDecoder().decode(source);
-            case 'ascii':
+            case "utf8":
+            case "utf-8":
+                return decode(source);
+            case "ascii":
                 {
-                    return String.fromCharCode(...u8.map((v)=>v & 0x7f));
+                    return toAsciiString(u8);
                 }
-            case 'latin1':
-            // falls through
-            case 'binary':
+            case "latin1":
+            case "binary":
                 {
-                    return String.fromCharCode(...u8);
+                    return toLatin1String(u8);
                 }
-            case 'ucs2':
-            // falls through
-            case 'ucs-2':
-            // case 'utf-16le':
-            // falls through
-            case 'utf16le':
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
                 {
-                    let res = '';
-                    // If length is odd, the last 8 bits must be ignored (same as node.js)
-                    for(let i = 0; i < u8.length - 1; i += 2){
-                        res += String.fromCharCode(u8[i] + u8[i + 1] * 256);
-                    }
-                    return res;
+                    return toUtf16LeString(u8);
                 }
             default:
-                throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${encoding}`);
+                throw new Error("[ArrayBuffers.toString] Unknown encoding: ".concat(encoding));
         }
     }
     /**
-   * toString convert the given {@link BufferSource} to string
-   */ ArrayBuffers.toString = toString;
-    function normalizeEncoding(encoding) {
-        switch(encoding?.toLowerCase()){
-            case 'utf-8':
-            case 'utf8':
-                return 'utf8';
-            case 'utf-16le':
-            case 'ucs2':
-            case 'ucs-2':
-                return 'utf16le';
-            case 'hex':
-            case 'ascii':
-            case 'latin1':
-            case 'binary':
-            case 'base64':
-            case 'utf16le':
+     * toString convert the given {@link BufferSource} to string
+     */ ArrayBuffers.toString = toString;
+    /**
+     * Normalize encoding string to standard form
+     * @param encoding - The encoding string to normalize
+     * @returns Normalized encoding or undefined if invalid
+     */ function normalizeEncoding(encoding) {
+        switch (encoding === null || encoding === void 0 ? void 0 : encoding.toLowerCase()) {
+            case "utf-8":
+            case "utf8":
+                return "utf8";
+            case "utf-16le":
+            case "ucs2":
+            case "ucs-2":
+                return "utf16le";
+            case "hex":
+            case "ascii":
+            case "latin1":
+            case "binary":
+            case "base64":
+            case "utf16le":
                 return encoding;
             default:
                 return undefined;
@@ -147,13 +157,16 @@ export var ArrayBuffers;
         return normalizeEncoding(v) !== undefined;
     }
     /**
-   * Returns true if encoding is the name of a supported character encoding, or false otherwise.
-   */ ArrayBuffers.isEncoding = isEncoding;
+     * Check if the given string is a supported character encoding
+     * @param v - The string to check
+     * @returns True if the encoding is supported, false otherwise
+     */ ArrayBuffers.isEncoding = isEncoding;
     function toJSON(v, reviver) {
         return JSON.parse(toString(v), reviver);
     }
     ArrayBuffers.toJSON = toJSON;
-    function from(src, encoding = 'utf8', view) {
+    function from(src) {
+        var encoding = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "utf8", view = arguments.length > 2 ? arguments[2] : void 0;
         if (!src) {
             return new (view || ArrayBuffer)(0);
         }
@@ -161,139 +174,179 @@ export var ArrayBuffers;
             return view ? asView(view, src) : src;
         }
         // Array<number> | Iterable<number>
-        if (typeof src !== 'string' && isIterable(src) || Array.isArray(src)) {
+        if (typeof src !== "string" && isIterable(src) || Array.isArray(src)) {
             return (view || Uint8Array).from(src);
         }
         if (view) {
             return asView(view, from(src, encoding));
         }
-        if (typeof src === 'string') {
-            // is string
+        if (typeof src === "string") {
             if (isNativeBufferAllowed()) {
                 return Buffer.from(src, encoding);
             }
-            switch(encoding){
-                case 'utf-8':
-                // falls through
-                case 'utf8':
-                    return new TextEncoder().encode(src).buffer;
-                case 'base64':
-                    // replaceAll need higher version of nodejs
-                    // return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
+            switch (encoding) {
+                case "utf-8":
+                case "utf8":
+                    return encode(src).buffer;
+                case "base64":
                     return fromBase64(src);
-                case 'hex':
-                    // return new Uint8Array(v.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))).buffer;
+                case "hex":
                     return fromHex(src);
                 default:
-                    throw new Error(`ArrayBuffers.from unsupported encoding: ${encoding}`);
+                    throw new Error("ArrayBuffers.from unsupported encoding: ".concat(encoding));
             }
         }
-        const type = classOf(src);
-        throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);
+        var type = classOf(src);
+        throw new TypeError("ArrayBuffers.from unsupported type ".concat(type));
     }
     ArrayBuffers.from = from;
-    function concat(buffers, result, offset = 0) {
-        // https://stackoverflow.com/questions/10786128/appending-arraybuffers
-        const length = buffers.reduce((a, b)=>a + b.byteLength, 0);
-        const r = result ? new Uint8Array(result) : new Uint8Array(length);
-        for (const buffer of buffers){
-            if (!buffer?.byteLength) continue;
-            let n;
-            if (buffer instanceof ArrayBuffer) {
-                n = new Uint8Array(buffer);
-            } else if (ArrayBuffer.isView(buffer)) {
-                n = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-            } else {
-                throw new Error(`ArrayBuffers.concat unsupported type ${classOf(buffer)}`);
+    function concat(buffers, result) {
+        var offset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+        if (!Array.isArray(buffers) || buffers.length === 0) {
+            return new ArrayBuffer(0);
+        }
+        var length = buffers.reduce(function (a, b) {
+            var _b_byteLength;
+            return a + ((_b_byteLength = b === null || b === void 0 ? void 0 : b.byteLength) !== null && _b_byteLength !== void 0 ? _b_byteLength : 0);
+        }, 0);
+        var r = result ? new Uint8Array(result) : new Uint8Array(length);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for (var _iterator = buffers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var buffer = _step.value;
+                if (!(buffer === null || buffer === void 0 ? void 0 : buffer.byteLength))
+                    continue;
+                var n = void 0;
+                if (_instanceof(buffer, ArrayBuffer)) {
+                    n = new Uint8Array(buffer);
+                }
+                else if (ArrayBuffer.isView(buffer)) {
+                    n = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+                }
+                else {
+                    throw new Error("ArrayBuffers.concat unsupported type ".concat(classOf(buffer)));
+                }
+                r.set(n, offset);
+                offset += buffer.byteLength;
+            }
+        }
+        catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        }
+        finally {
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            }
+            finally {
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
             }
-            r.set(n, offset);
-            offset += buffer.byteLength;
         }
         return r.buffer;
     }
     /**
-   * concat the given {@link BufferSource} to a new {@link ArrayBuffer}
-   */ ArrayBuffers.concat = concat;
-    function fromBase64(v) {
-        if ('fromBase64' in Uint8Array) {
+     * concat the given {@link BufferSource} to a new {@link ArrayBuffer}
+     */ ArrayBuffers.concat = concat;
+    function fromBase64(v, encoding) {
+        if (encoding) {
+            return toString(fromBase64(v), encoding);
+        }
+        if ("fromBase64" in Uint8Array && typeof Uint8Array.fromBase64 === "function") {
             return Uint8Array.fromBase64(v);
         }
         if (isNativeBufferAllowed()) {
-            return Buffer.from(v, 'base64');
+            return Buffer.from(v, "base64");
         }
-        return decodeBase64ToUint8Array(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
+        // Clean the base64 string by removing invalid characters
+        return decodeBase64ToUint8Array(v.replace(/[^0-9a-zA-Z=+/_]/g, ""));
     }
     ArrayBuffers.fromBase64 = fromBase64;
-    function fromHex(v) {
-        if ('fromHex' in Uint8Array) {
+    function fromHex(v, encoding) {
+        if (encoding) {
+            return toString(fromHex(v), encoding);
+        }
+        if ("fromHex" in Uint8Array && typeof Uint8Array.fromHex === "function") {
             return Uint8Array.fromHex(v);
         }
         if (isNativeBufferAllowed()) {
-            return Buffer.from(v, 'hex');
+            return Buffer.from(v, "hex");
         }
-        return new Uint8Array(v.match(/.{1,2}/g).map((byte)=>parseInt(byte, 16)));
+        // Handle odd-length hex strings by padding with leading zero
+        var cleanHex = v.length % 2 === 1 ? "0" + v : v;
+        var matches = cleanHex.match(/.{1,2}/g);
+        if (!matches) {
+            throw new Error("Invalid hex string");
+        }
+        var num = matches.map(function (byte) {
+            return parseInt(byte, 16);
+        });
+        return new Uint8Array(num);
     }
     ArrayBuffers.fromHex = fromHex;
     function toBase64(source) {
-        if (typeof source === 'string') {
-            source = new TextEncoder().encode(source);
-        }
-        if ('toBase64' in Uint8Array.prototype) {
+        source = encode(source);
+        if ("toBase64" in Uint8Array.prototype) {
             return toUint8Array(source).toBase64();
         }
         if (isNativeBufferAllowed()) {
-            return Buffer.from(asView(Uint8Array, source)).toString('base64');
+            return Buffer.from(asView(Uint8Array, source)).toString("base64");
         }
         return encodeArrayBufferToBase64(toArrayBuffer(source));
     }
     /**
-   * toBase64 convert the given {@link BufferSource} to base64 string
-   * @param source if string, will be encoded as utf8
-   */ ArrayBuffers.toBase64 = toBase64;
+     * toBase64 convert the given {@link BufferSource} to base64 string
+     * @param source if string, will be encoded as utf8
+     */ ArrayBuffers.toBase64 = toBase64;
     function toHex(v) {
-        if ('toHex' in Uint8Array.prototype) {
+        v = encode(v);
+        if ("toHex" in Uint8Array.prototype) {
             return toUint8Array(v).toHex();
         }
         if (isNativeBufferAllowed()) {
-            return Buffer.from(asView(Uint8Array, v)).toString('hex');
+            return Buffer.from(asView(Uint8Array, v)).toString("hex");
         }
-        return toString(v, 'hex');
+        return toString(v, "hex");
     }
     ArrayBuffers.toHex = toHex;
     function resize(v, newByteLength, maxByteLength) {
         if (newByteLength === undefined || newByteLength === null) {
             return v;
         }
-        // Chrome 111, Nodejs 20
-        if ('resize' in v && typeof v.resize === 'function') {
-            if ('resizable' in v && v.resizable) {
-                if ('maxByteLength' in v && typeof v.maxByteLength === 'number' && v.maxByteLength >= newByteLength) {
+        // Chrome 111, Nodejs 20 - use native resize if available
+        if ("resize" in v && typeof v.resize === "function") {
+            if ("resizable" in v && v.resizable) {
+                if ("maxByteLength" in v && typeof v.maxByteLength === "number" && v.maxByteLength >= newByteLength) {
                     v.resize(newByteLength);
                     return v;
                 }
             }
         }
-        const old = v;
-        const newBuf = new ArrayBuffer(newByteLength, {
+        // Fallback: create new buffer and copy data
+        var old = v;
+        var newBuf = new ArrayBuffer(newByteLength, {
             maxByteLength: maxByteLength
         });
-        const oldView = new Uint8Array(old);
-        const newView = new Uint8Array(newBuf);
+        var oldView = new Uint8Array(old);
+        var newView = new Uint8Array(newBuf);
         newView.set(oldView);
         return newBuf;
     }
     ArrayBuffers.resize = resize;
     function toArrayBuffer(v) {
-        if (v instanceof ArrayBuffer) {
+        if (_instanceof(v, ArrayBuffer)) {
             return v;
         }
         if (ArrayBuffer.isView(v)) {
             if (v.byteOffset > 0) {
-                throw new Error('ArrayBuffers.toArrayBuffer do not support view with offset');
+                throw new Error("ArrayBuffers.toArrayBuffer does not support view with offset");
             }
             return v.buffer;
         }
-        throw new Error(`ArrayBuffers.toArrayBuffer unsupported type ${classOf(v)}`);
+        throw new Error("ArrayBuffers.toArrayBuffer unsupported type ".concat(classOf(v)));
     }
     ArrayBuffers.toArrayBuffer = toArrayBuffer;
     function toUint8Array(v) {
@@ -302,33 +355,205 @@ export var ArrayBuffers;
     ArrayBuffers.toUint8Array = toUint8Array;
     function alloc(size, fill, encoding) {
         if (fill !== undefined) {
-            if (typeof fill === 'number') {
+            if (typeof fill === "number") {
                 return new Uint8Array(size).fill(fill);
             }
-            // as cast
+            // Convert string to buffer and slice to size
             // https://stackoverflow.com/questions/73994091
             return asView(Uint8Array, from(fill, encoding)).slice(0, size);
         }
         return new ArrayBuffer(size);
     }
-    ArrayBuffers.alloc = alloc;
+    /**
+     * Allocate a new ArrayBuffer or Uint8Array with optional fill value
+     * @param size - The size in bytes to allocate
+     * @param fill - Optional fill value (number or string)
+     * @param encoding - Encoding for string fill value (default: 'utf8')
+     * @returns ArrayBuffer or Uint8Array
+     */ ArrayBuffers.alloc = alloc;
+    // Helper functions for string conversion
+    /**
+     * Convert Uint8Array to hex string efficiently
+     * @param u8 - The Uint8Array to convert
+     * @returns Hex string representation
+     */ function toHexString(u8) {
+        var result = "";
+        for (var i = 0; i < u8.length; i++) {
+            result += hexLookupTable[u8[i]];
+        }
+        return result;
+    }
+    /**
+     * Convert Uint8Array to ASCII string
+     * @param u8 - The Uint8Array to convert
+     * @returns ASCII string representation
+     */ function toAsciiString(u8) {
+        var result = "";
+        for (var i = 0; i < u8.length; i++) {
+            result += String.fromCharCode(u8[i] & 127);
+        }
+        return result;
+    }
+    /**
+     * Convert Uint8Array to Latin1 string
+     * @param u8 - The Uint8Array to convert
+     * @returns Latin1 string representation
+     */ function toLatin1String(u8) {
+        var result = "";
+        for (var i = 0; i < u8.length; i++) {
+            result += String.fromCharCode(u8[i]);
+        }
+        return result;
+    }
+    /**
+     * Convert Uint8Array to UTF-16LE string
+     * @param u8 - The Uint8Array to convert
+     * @returns UTF-16LE string representation
+     */ function toUtf16LeString(u8) {
+        var result = "";
+        // If length is odd, the last 8 bits must be ignored (same as node.js)
+        for (var i = 0; i < u8.length - 1; i += 2) {
+            result += String.fromCharCode(u8[i] + u8[i + 1] * 256);
+        }
+        return result;
+    }
+    // base16 lookup table for efficient hex conversion
+    var hexLookupTable = function () {
+        var alphabet = "0123456789abcdef";
+        var table = new Array(256);
+        for (var i = 0; i < 16; ++i) {
+            var i16 = i * 16;
+            for (var j = 0; j < 16; ++j) {
+                table[i16 + j] = alphabet[i] + alphabet[j];
+            }
+        }
+        return table;
+    }();
+    // Helper functions for internal use
+    function isIterable(obj) {
+        return obj != null && typeof (obj === null || obj === void 0 ? void 0 : obj[Symbol.iterator]) === "function";
+    }
+    function isBufferSource(value) {
+        return ArrayBuffer.isView(value) || _instanceof(value, ArrayBuffer);
+    }
+    function equals(a, b) {
+        if (a === b)
+            return true;
+        var aView = asView(Uint8Array, a);
+        var bView = asView(Uint8Array, b);
+        if (aView.length !== bView.length) {
+            return false;
+        }
+        for (var i = 0; i < aView.length; i++) {
+            if (aView[i] !== bView[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if two BufferSources are equal
+     * @param a - First buffer source
+     * @param b - Second buffer source
+     * @returns True if buffers are equal, false otherwise
+     */ ArrayBuffers.equals = equals;
+    function compare(a, b) {
+        if (a === b)
+            return 0;
+        var aView = asView(Uint8Array, a);
+        var bView = asView(Uint8Array, b);
+        var minLength = Math.min(aView.length, bView.length);
+        for (var i = 0; i < minLength; i++) {
+            if (aView[i] < bView[i])
+                return -1;
+            if (aView[i] > bView[i])
+                return 1;
+        }
+        return aView.length - bView.length;
+    }
+    /**
+     * Compare two BufferSources lexicographically
+     * @param a - First buffer source
+     * @param b - Second buffer source
+     * @returns -1 if a < b, 0 if a === b, 1 if a > b
+     */ ArrayBuffers.compare = compare;
+    function startsWith(buffer, prefix) {
+        var bufferView = asView(Uint8Array, buffer);
+        var prefixView = asView(Uint8Array, prefix);
+        if (prefixView.length > bufferView.length) {
+            return false;
+        }
+        for (var i = 0; i < prefixView.length; i++) {
+            if (bufferView[i] !== prefixView[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if a BufferSource starts with another BufferSource
+     * @param buffer - The buffer to check
+     * @param prefix - The prefix to check for
+     * @returns True if buffer starts with prefix, false otherwise
+     */ ArrayBuffers.startsWith = startsWith;
+    function endsWith(buffer, suffix) {
+        var bufferView = asView(Uint8Array, buffer);
+        var suffixView = asView(Uint8Array, suffix);
+        if (suffixView.length > bufferView.length) {
+            return false;
+        }
+        var offset = bufferView.length - suffixView.length;
+        for (var i = 0; i < suffixView.length; i++) {
+            if (bufferView[offset + i] !== suffixView[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if a BufferSource ends with another BufferSource
+     * @param buffer - The buffer to check
+     * @param suffix - The suffix to check for
+     * @returns True if buffer ends with suffix, false otherwise
+     */ ArrayBuffers.endsWith = endsWith;
+    function indexOf(buffer, search) {
+        var startIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+        var bufferView = asView(Uint8Array, buffer);
+        var searchView = asView(Uint8Array, search);
+        if (searchView.length === 0)
+            return startIndex;
+        if (searchView.length > bufferView.length)
+            return -1;
+        for (var i = startIndex; i <= bufferView.length - searchView.length; i++) {
+            var found = true;
+            for (var j = 0; j < searchView.length; j++) {
+                if (bufferView[i + j] !== searchView[j]) {
+                    found = false;
+                    break;
+                }
+            }
+            if (found)
+                return i;
+        }
+        return -1;
+    }
+    /**
+     * Find the index of a sub-buffer within a buffer
+     * @param buffer - The buffer to search in
+     * @param search - The sub-buffer to search for
+     * @param startIndex - Starting index for search (default: 0)
+     * @returns Index of first occurrence, or -1 if not found
+     */ ArrayBuffers.indexOf = indexOf;
+    function subarray(buffer, start, end) {
+        var view = asView(Uint8Array, buffer);
+        return view.subarray(start, end);
+    }
+    /**
+     * Get a sub-buffer from a buffer
+     * @param buffer - The source buffer
+     * @param start - Start index (inclusive)
+     * @param end - End index (exclusive, optional)
+     * @returns New Uint8Array containing the sub-buffer
+     */ ArrayBuffers.subarray = subarray;
 })(ArrayBuffers || (ArrayBuffers = {}));
-const hexLookupTable = function() {
-    const alphabet = '0123456789abcdef';
-    const table = new Array(256);
-    for(let i = 0; i < 16; ++i){
-        const i16 = i * 16;
-        for(let j = 0; j < 16; ++j){
-            table[i16 + j] = alphabet[i] + alphabet[j];
-        }
-    }
-    return table;
-}();
-function isIterable(obj) {
-    return typeof obj?.[Symbol.iterator] === 'function';
-}
-function isBufferSource(v) {
-    return ArrayBuffer.isView(v) || v instanceof ArrayBuffer;
-}
-
-//# sourceMappingURL=ArrayBuffers.js.map
+export var ArrayBuffers;