@wener/utils 1.1.51 → 1.1.53

package/lib/io/ArrayBuffers.js

@@ -1,334 +1,2 @@
-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 isNativeBufferAvailable() {
-        // eslint-disable-next-line no-return-assign
-        return isBufferAvailable ??= !getGlobalThis().Buffer?.isPollyfill?.();
-    }
-    /**
-   * 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 v instanceof ArrayBuffer;
-    }
-    /**
-   * isArrayBuffer check if the given value is an {@link 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 (v instanceof TypedArray && (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 ?? 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':
-                    return btoa(source);
-                case 'utf-8':
-                case 'utf8':
-                    return source;
-                default:
-                    throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);
-            }
-        }
-        let 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 [
-                        ...u8
-                    ].map((b)=>hexLookupTable[b]).join('');
-                }
-            case 'base64':
-                {
-                    return encodeArrayBufferToBase64(u8);
-                }
-            case 'utf8':
-            // falls through
-            case 'utf-8':
-                return new TextDecoder().decode(source);
-            case 'ascii':
-                {
-                    return String.fromCharCode(...u8.map((v)=>v & 0x7f));
-                }
-            case 'latin1':
-            // falls through
-            case 'binary':
-                {
-                    return String.fromCharCode(...u8);
-                }
-            case 'ucs2':
-            // falls through
-            case 'ucs-2':
-            // case 'utf-16le':
-            // falls through
-            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;
-                }
-            default:
-                throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${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':
-                return encoding;
-            default:
-                return undefined;
-        }
-    }
-    function isEncoding(v) {
-        return normalizeEncoding(v) !== undefined;
-    }
-    /**
-   * Returns true if encoding is the name of a supported character encoding, or false otherwise.
-   */ ArrayBuffers.isEncoding = isEncoding;
-    function toJSON(v, reviver) {
-        return JSON.parse(toString(v), reviver);
-    }
-    ArrayBuffers.toJSON = toJSON;
-    function from(src, encoding = 'utf8', view) {
-        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') {
-            // is 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, ''));
-                    return fromBase64(src);
-                case 'hex':
-                    // return new Uint8Array(v.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))).buffer;
-                    return fromHex(src);
-                default:
-                    throw new Error(`ArrayBuffers.from unsupported encoding: ${encoding}`);
-            }
-        }
-        const type = classOf(src);
-        throw new TypeError(`ArrayBuffers.from unsupported type ${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)}`);
-            }
-            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) {
-            return Uint8Array.fromBase64(v);
-        }
-        if (isNativeBufferAllowed()) {
-            return Buffer.from(v, 'base64');
-        }
-        return decodeBase64ToUint8Array(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
-    }
-    ArrayBuffers.fromBase64 = fromBase64;
-    function fromHex(v) {
-        if ('fromHex' in Uint8Array) {
-            return Uint8Array.fromHex(v);
-        }
-        if (isNativeBufferAllowed()) {
-            return Buffer.from(v, 'hex');
-        }
-        return new Uint8Array(v.match(/.{1,2}/g).map((byte)=>parseInt(byte, 16)));
-    }
-    ArrayBuffers.fromHex = fromHex;
-    function toBase64(source) {
-        if (typeof source === 'string') {
-            source = new TextEncoder().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) {
-        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
-        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, {
-            maxByteLength: maxByteLength
-        });
-        const oldView = new Uint8Array(old);
-        const newView = new Uint8Array(newBuf);
-        newView.set(oldView);
-        return newBuf;
-    }
-    ArrayBuffers.resize = resize;
-    function toArrayBuffer(v) {
-        if (v instanceof ArrayBuffer) {
-            return v;
-        }
-        if (ArrayBuffer.isView(v)) {
-            if (v.byteOffset > 0) {
-                throw new Error('ArrayBuffers.toArrayBuffer do not support view with offset');
-            }
-            return v.buffer;
-        }
-        throw new Error(`ArrayBuffers.toArrayBuffer unsupported type ${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);
-            }
-            // as cast
-            // https://stackoverflow.com/questions/73994091
-            return asView(Uint8Array, from(fill, encoding)).slice(0, size);
-        }
-        return new ArrayBuffer(size);
-    }
-    ArrayBuffers.alloc = alloc;
-})(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
+import * as _ArrayBuffers from "./ArrayBuffers.mod.js";
+export { _ArrayBuffers as ArrayBuffers };