@wener/utils 1.1.53 → 1.1.54

package/lib/io/ArrayBuffers.js

@@ -1,2 +1,559 @@
-import * as _ArrayBuffers from "./ArrayBuffers.mod.js";
-export { _ArrayBuffers as ArrayBuffers };
+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 !== 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;
+    function isNativeBufferAllowed() {
+        return Boolean(nativeBufferAllowed && isBufferAvailable);
+    }
+    ArrayBuffers.isNativeBufferAllowed = isNativeBufferAllowed;
+    function setNativeBufferAllowed(v) {
+        nativeBufferAllowed = v;
+    }
+    ArrayBuffers.setNativeBufferAllowed = setNativeBufferAllowed;
+    function isArrayBuffer(v) {
+        return _instanceof(v, ArrayBuffer);
+    }
+    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
+        if (isBuffer(o)) {
+            return Uint8Array.prototype.slice.call(o, start, end);
+        }
+        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;
+    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);
+    }
+    /**
+     * 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":
+                    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));
+        }
+    }
+    /**
+     * 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;
+        }
+    }
+    function isEncoding(v) {
+        return normalizeEncoding(v) !== 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
+     */ ArrayBuffers.isEncoding = isEncoding;
+    function toJSON(v, reviver) {
+        return JSON.parse(toString(v), reviver);
+    }
+    ArrayBuffers.toJSON = toJSON;
+    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));
+    }
+    ArrayBuffers.from = from;
+    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;
+    }
+    /**
+     * 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");
+        }
+        // Clean the base64 string by removing invalid characters
+        return decodeBase64ToUint8Array(v.replace(/[^0-9a-zA-Z=+/_]/g, ""));
+    }
+    ArrayBuffers.fromBase64 = fromBase64;
+    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);
+    }
+    ArrayBuffers.fromHex = fromHex;
+    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));
+    }
+    /**
+     * toBase64 convert the given {@link BufferSource} to base64 string
+     * @param source if string, will be encoded as utf8
+     */ ArrayBuffers.toBase64 = toBase64;
+    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");
+    }
+    ArrayBuffers.toHex = toHex;
+    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;
+    }
+    ArrayBuffers.resize = resize;
+    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)));
+    }
+    ArrayBuffers.toArrayBuffer = toArrayBuffer;
+    function toUint8Array(v) {
+        return asView(Uint8Array, v);
+    }
+    ArrayBuffers.toUint8Array = toUint8Array;
+    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);
+    }
+    /**
+     * 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 = {}));
+export var ArrayBuffers;

package/lib/langs/parseDate.js

@@ -0,0 +1,20 @@
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+export function parseDate(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (_instanceof(value, Date)) {
+        return value;
+    }
+    var parsed = new Date(value);
+    if (isNaN(parsed.getTime())) {
+        return undefined;
+    }
+    return parsed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.53",
+  "version": "1.1.54",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {
@@ -70,7 +70,7 @@
     "https-proxy-agent": "^7.0.6",
     "node-fetch": "^3.3.2",
     "undici": "^7.16.0",
-    "zod": "^4.1.9"
+    "zod": "^4.1.12"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",