@wener/utils 1.1.51 → 1.1.53

package/lib/io/ArrayBuffers.mod.js

@@ -0,0 +1,531 @@
+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";
+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;
+}
+/**
+ * isNativeBufferAvailable check if the native {@link Buffer} is available
+ */ export function isNativeBufferAvailable() {
+    var _getGlobalThis_Buffer_isPollyfill, _getGlobalThis_Buffer;
+    // eslint-disable-next-line no-return-assign
+    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));
+}
+export function isNativeBufferAllowed() {
+    return Boolean(nativeBufferAllowed && isBufferAvailable);
+}
+export function setNativeBufferAllowed(v) {
+    nativeBufferAllowed = v;
+}
+export function isArrayBuffer(v) {
+    return _instanceof(v, ArrayBuffer);
+}
+/**
+ * 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}
+ */ export function slice(o, start, end) {
+    // NodeJS Buffer slice is not the same as UInt8Array slice
+    // https://nodejs.org/api/buffer.html#bufslicestart-end
+    if (isBuffer(o)) {
+        return Uint8Array.prototype.slice.call(o, start, end);
+    }
+    return o.slice(start, end);
+}
+/**
+ * asView convert the given value to given {@link TypedArray} view
+ *
+ * TypedArray can be {@link Buffer}, will avoid copy
+ */ export function asView(TypedArray, v, byteOffset, byteLength) {
+    if (_instanceof(v, TypedArray) && (byteOffset !== null && byteOffset !== void 0 ? byteOffset : 0) === 0 && byteLength === undefined) {
+        return v;
+    }
+    if (ArrayBuffer.isView(v) || isBuffer(v)) {
+        if (isNativeBufferAllowed() && TypedArray === Buffer) {
+            // new Buffer() is deprecated
+            return Buffer.from(v.buffer, byteOffset, 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);
+}
+/**
+ * toString convert the given {@link BufferSource} to string
+ */ export 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":
+                return source;
+            default:
+                throw new Error("[ArrayBuffers.toString] Unsupported encoding for string: ".concat(encoding));
+        }
+    }
+    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":
+            {
+                return toHexString(u8);
+            }
+        case "base64":
+            {
+                return toBase64(u8);
+            }
+        case "utf8":
+        case "utf-8":
+            return decode(source);
+        case "ascii":
+            {
+                return toAsciiString(u8);
+            }
+        case "latin1":
+        case "binary":
+            {
+                return toLatin1String(u8);
+            }
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+            {
+                return toUtf16LeString(u8);
+            }
+        default:
+            throw new Error("[ArrayBuffers.toString] Unknown encoding: ".concat(encoding));
+    }
+}
+/**
+ * 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;
+    }
+}
+/**
+ * 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
+ */ export function isEncoding(v) {
+    return normalizeEncoding(v) !== undefined;
+}
+export function toJSON(v, reviver) {
+    return JSON.parse(toString(v), reviver);
+}
+export 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);
+    }
+    if (isBufferSource(src)) {
+        return view ? asView(view, src) : src;
+    }
+    // Array<number> | Iterable<number>
+    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") {
+        if (isNativeBufferAllowed()) {
+            return Buffer.from(src, encoding);
+        }
+        switch (encoding) {
+            case "utf-8":
+            case "utf8":
+                return encode(src).buffer;
+            case "base64":
+                return fromBase64(src);
+            case "hex":
+                return fromHex(src);
+            default:
+                throw new Error("ArrayBuffers.from unsupported encoding: ".concat(encoding));
+        }
+    }
+    var type = classOf(src);
+    throw new TypeError("ArrayBuffers.from unsupported type ".concat(type));
+}
+/**
+ * concat the given {@link BufferSource} to a new {@link ArrayBuffer}
+ */ export 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;
+            }
+        }
+    }
+    return r.buffer;
+}
+export 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");
+    }
+    // Clean the base64 string by removing invalid characters
+    return decodeBase64ToUint8Array(v.replace(/[^0-9a-zA-Z=+/_]/g, ""));
+}
+export 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");
+    }
+    // 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);
+}
+/**
+ * toBase64 convert the given {@link BufferSource} to base64 string
+ * @param source if string, will be encoded as utf8
+ */ export function toBase64(source) {
+    source = encode(source);
+    if ("toBase64" in Uint8Array.prototype) {
+        return toUint8Array(source).toBase64();
+    }
+    if (isNativeBufferAllowed()) {
+        return Buffer.from(asView(Uint8Array, source)).toString("base64");
+    }
+    return encodeArrayBufferToBase64(toArrayBuffer(source));
+}
+export function toHex(v) {
+    v = encode(v);
+    if ("toHex" in Uint8Array.prototype) {
+        return toUint8Array(v).toHex();
+    }
+    if (isNativeBufferAllowed()) {
+        return Buffer.from(asView(Uint8Array, v)).toString("hex");
+    }
+    return toString(v, "hex");
+}
+export function resize(v, newByteLength, maxByteLength) {
+    if (newByteLength === undefined || newByteLength === null) {
+        return v;
+    }
+    // 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;
+            }
+        }
+    }
+    // Fallback: create new buffer and copy data
+    var old = v;
+    var newBuf = new ArrayBuffer(newByteLength, {
+        maxByteLength: maxByteLength
+    });
+    var oldView = new Uint8Array(old);
+    var newView = new Uint8Array(newBuf);
+    newView.set(oldView);
+    return newBuf;
+}
+export function toArrayBuffer(v) {
+    if (_instanceof(v, ArrayBuffer)) {
+        return v;
+    }
+    if (ArrayBuffer.isView(v)) {
+        if (v.byteOffset > 0) {
+            throw new Error("ArrayBuffers.toArrayBuffer does not support view with offset");
+        }
+        return v.buffer;
+    }
+    throw new Error("ArrayBuffers.toArrayBuffer unsupported type ".concat(classOf(v)));
+}
+export function toUint8Array(v) {
+    return asView(Uint8Array, v);
+}
+/**
+ * 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
+ */ export function alloc(size, fill, encoding) {
+    if (fill !== undefined) {
+        if (typeof fill === "number") {
+            return new Uint8Array(size).fill(fill);
+        }
+        // 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);
+}
+// 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);
+}
+/**
+ * Check if two BufferSources are equal
+ * @param a - First buffer source
+ * @param b - Second buffer source
+ * @returns True if buffers are equal, false otherwise
+ */ export 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;
+}
+/**
+ * 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
+ */ export 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;
+}
+/**
+ * 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
+ */ export 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 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
+ */ export 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;
+}
+/**
+ * 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
+ */ export 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;
+}
+/**
+ * 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
+ */ export function subarray(buffer, start, end) {
+    var view = asView(Uint8Array, buffer);
+    return view.subarray(start, end);
+}

package/lib/io/ArrayBuffers.test.js

@@ -0,0 +1,77 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr))
+        return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+        return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { expect, test } from "vitest";
+import { ArrayBuffers } from "./ArrayBuffers.js";
+test("concat", function () {
+    var check = function () {
+        var Type = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Uint8Array, va = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [
+            1,
+            2,
+            3
+        ], vb = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [
+            4,
+            5,
+            6
+        ];
+        var a = new Type(va);
+        var b = new Type(vb);
+        expect(ArrayBuffers.concat([
+            a,
+            b
+        ]), "should concat ".concat(Type)).toStrictEqual(new Type(_to_consumable_array(va).concat(_to_consumable_array(vb))).buffer);
+    };
+    check(Uint8Array);
+    check(Uint16Array, [
+        255,
+        65535
+    ]);
+    check(Uint32Array, [
+        268435455
+    ]);
+});
+test("asView for Buffer", function () {
+    var buf = Buffer.from([
+        1,
+        2,
+        3,
+        4,
+        5
+    ]);
+    expect(ArrayBuffers.asView(Buffer, buf)).toBe(buf);
+    var uint8 = ArrayBuffers.asView(Uint8Array, buf);
+    expect(ArrayBuffers.asView(Buffer, uint8).buffer).toBe(buf.buffer);
+    expect(uint8).toEqual(buf);
+    expect(ArrayBuffers.asView(Buffer, uint8)).toEqual(buf);
+});