@wener/utils 1.1.49 → 1.1.50

package/lib/io/ArrayBuffers.js

@@ -1,150 +1,106 @@
 import { classOf } from '../langs/classOf.js';
 import { getGlobalThis } from '../runtime/getGlobalThis.js';
-import { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64.js';
+import { decodeBase64ToUint8Array, encodeArrayBufferToBase64 } from './base64.js';
 import { isBuffer } from './isBuffer.js';
-export class ArrayBuffers {
-    static #nativeBufferAllowed = true;
-    static #isBufferAvailable;
-    static isNativeBufferAvailable() {
+export var ArrayBuffers;
+(function(ArrayBuffers) {
+    let nativeBufferAllowed = true;
+    let isBufferAvailable;
+    function isNativeBufferAvailable() {
         // eslint-disable-next-line no-return-assign
-        return this.#isBufferAvailable ??= !getGlobalThis().Buffer?.isPollyfill?.();
+        return isBufferAvailable ??= !getGlobalThis().Buffer?.isPollyfill?.();
     }
-    static isNativeBufferAllowed() {
-        return this.#nativeBufferAllowed && this.#isBufferAvailable;
+    /**
+   * isNativeBufferAvailable check if the native {@link Buffer} is available
+   */ ArrayBuffers.isNativeBufferAvailable = isNativeBufferAvailable;
+    function isNativeBufferAllowed() {
+        return Boolean(nativeBufferAllowed && isBufferAvailable);
     }
-    static setNativeBufferAllowed(v) {
-        this.#nativeBufferAllowed = v;
+    ArrayBuffers.isNativeBufferAllowed = isNativeBufferAllowed;
+    function setNativeBufferAllowed(v) {
+        nativeBufferAllowed = v;
     }
-    static isArrayBuffer = (v)=>{
+    ArrayBuffers.setNativeBufferAllowed = setNativeBufferAllowed;
+    function isArrayBuffer(v) {
         return v instanceof ArrayBuffer;
-    };
-    static toArrayBuffer(v) {
-        return v instanceof ArrayBuffer ? v : v.buffer;
     }
-    static toUint8Array(v) {
-        return ArrayBuffers.asView(Uint8Array, v);
-    }
-    static toBase64 = (v)=>{
-        if ('toBase64' in Uint8Array.prototype) {
-            return this.toUint8Array(v).toBase64();
-        }
-        if (ArrayBuffers.isNativeBufferAllowed()) {
-            return Buffer.from(ArrayBuffers.asView(Uint8Array, v)).toString('base64');
-        }
-        return encodeArrayBufferToBase64(this.toArrayBuffer(v));
-    };
-    static toHex = (v)=>{
-        if ('toHex' in Uint8Array.prototype) {
-            return this.toUint8Array(v).toHex();
-        }
-        if (ArrayBuffers.isNativeBufferAllowed()) {
-            return Buffer.from(ArrayBuffers.asView(Uint8Array, v)).toString('hex');
-        }
-        return ArrayBuffers.toString(v, 'hex');
-    };
-    static fromBase64 = (v)=>{
-        if ('fromBase64' in Uint8Array) {
-            return Uint8Array.fromBase64(v);
-        }
-        if (ArrayBuffers.isNativeBufferAllowed()) {
-            return Buffer.from(v, 'base64');
-        }
-        return this.toUint8Array(decodeBase64ToArrayBuffer(v));
-    };
-    static fromHex = (v)=>{
-        if ('fromHex' in Uint8Array) {
-            return Uint8Array.fromHex(v);
-        }
-        return this.toUint8Array(ArrayBuffers.from(v, 'hex'));
-    };
-    static 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;
-    };
-    static slice = (o, start, end)=>{
+    /**
+   * 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);
-    };
-    static asView = (TypedArray, v, byteOffset, byteLength)=>{
+    }
+    /**
+   * 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 (ArrayBuffers.isNativeBufferAllowed() && TypedArray === Buffer) {
+            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);
-    };
-    static toString = (buf, encoding = 'utf8')=>{
+    }
+    /**
+   * 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 buf === 'string') {
+        if (typeof source === 'string') {
             switch(encoding){
                 case 'base64':
-                    return btoa(buf);
+                    return btoa(source);
                 case 'utf-8':
                 case 'utf8':
-                    return buf;
+                    return source;
                 default:
                     throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);
             }
         }
-        if (ArrayBuffers.isNativeBufferAllowed()) {
-            return Buffer.from(ArrayBuffers.asView(Uint8Array, buf)).toString(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':
                 {
-                    const view = ArrayBuffers.asView(Uint8Array, buf);
                     return [
-                        ...view
+                        ...u8
                     ].map((b)=>hexLookupTable[b]).join('');
                 }
             case 'base64':
                 {
-                    return encodeArrayBufferToBase64(ArrayBuffers.asView(Uint8Array, buf));
+                    return encodeArrayBufferToBase64(u8);
                 }
             case 'utf8':
             // falls through
             case 'utf-8':
-                return new TextDecoder().decode(buf);
+                return new TextDecoder().decode(source);
             case 'ascii':
                 {
-                    const view = ArrayBuffers.asView(Uint8Array, buf);
-                    return String.fromCharCode(...view.map((v)=>v & 0x7f));
+                    return String.fromCharCode(...u8.map((v)=>v & 0x7f));
                 }
             case 'latin1':
             // falls through
             case 'binary':
                 {
-                    const view = ArrayBuffers.asView(Uint8Array, buf);
-                    return String.fromCharCode(...view);
+                    return String.fromCharCode(...u8);
                 }
             case 'ucs2':
             // falls through
@@ -153,109 +109,90 @@ export class ArrayBuffers {
             // falls through
             case 'utf16le':
                 {
-                    const view = ArrayBuffers.asView(Uint8Array, buf);
                     let res = '';
                     // If length is odd, the last 8 bits must be ignored (same as node.js)
-                    for(let i = 0; i < view.length - 1; i += 2){
-                        res += String.fromCharCode(view[i] + view[i + 1] * 256);
+                    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}`);
         }
-    };
-    static toJSON = (v, reviver)=>{
-        return JSON.parse(ArrayBuffers.toString(v), reviver);
-    };
-    static 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 ArrayBuffers.asView(Uint8Array, ArrayBuffers.from(fill, encoding)).slice(0, size);
+    }
+    /**
+   * 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;
         }
-        return new ArrayBuffer(size);
-    };
-    static from = (v, encoding = 'utf8', view)=>{
-        if (view) {
-            return this.asView(view, this.from(v, encoding));
+    }
+    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 (!v) {
-            return new ArrayBuffer(0);
+        if (isBufferSource(src)) {
+            return view ? asView(view, src) : src;
         }
-        if (typeof v === 'string') {
-            if (ArrayBuffers.isNativeBufferAllowed()) {
-                return Buffer.from(v, encoding);
+        // 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(v).buffer;
+                    return new TextEncoder().encode(src).buffer;
                 case 'base64':
                     // replaceAll need higher version of nodejs
-                    return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
+                    // 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 new Uint8Array(v.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))).buffer;
+                    return fromHex(src);
                 default:
-                    throw new Error(`[ArrayBuffers.from] Unknown encoding: ${encoding}`);
-            }
-        }
-        if (v instanceof ArrayBuffer) {
-            return v;
-        }
-        // lost length
-        if (ArrayBuffer.isView(v) || isBuffer(v)) {
-            if (v.byteOffset !== 0) {
-                // return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength)
-                throw new Error('ArrayBuffers.from do not support view with offset');
+                    throw new Error(`ArrayBuffers.from unsupported encoding: ${encoding}`);
             }
-            return v.buffer;
-        }
-        if (Array.isArray(v)) {
-            return new Uint8Array(v);
         }
-        const type = classOf(v);
+        const type = classOf(src);
         throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);
-    };
-    static isEncoding = (encoding)=>{
-        switch(String(encoding).toLowerCase()){
-            case 'hex':
-            case 'utf8':
-            case 'utf-8':
-            case 'ascii':
-            case 'latin1':
-            case 'binary':
-            case 'base64':
-            case 'ucs2':
-            case 'ucs-2':
-            case 'utf16le':
-                // case 'utf-16le':
-                return true;
-            default:
-                return false;
-        }
-    };
-    // static truncate = (a: ArrayBufferLike, len?: number) => {
-    //   if (len === 0) {
-    //     return new ArrayBuffer(0);
-    //   }
-    //   if (!len) {
-    //     return a;
-    //   }
-    //   if (a.byteLength > len) {
-    //     return a.slice(0, len);
-    //   } else if (a.byteLength < len) {
-    //     let b = new Uint8Array(len);
-    //     b.set(new Uint8Array(a));
-    //     return b;
-    //   }
-    //   return a;
-    // };
-    static concat = (buffers, result, offset = 0)=>{
+    }
+    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);
@@ -273,8 +210,109 @@ export class ArrayBuffers {
             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);
@@ -286,5 +324,11 @@ const hexLookupTable = function() {
     }
     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

package/lib/io/ArrayBuffers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/io/ArrayBuffers.ts"],"sourcesContent":["import { classOf } from '../langs/classOf';\nimport { getGlobalThis } from '../runtime/getGlobalThis';\nimport { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64';\nimport { isBuffer } from './isBuffer';\n\n/**\n * Various utils to work with {@link ArrayBuffer}\n *\n * @see https://github.com/tc39/proposal-arraybuffer-base64\n * @see https://github.com/tc39/proposal-resizablearraybuffer\n */\nexport interface ArrayBuffers {\n  /**\n   * isArrayBuffer check if the given value is an {@link ArrayBuffer}\n   */\n  isArrayBuffer(v: any): v is ArrayBuffer;\n\n  /**\n   * slice the given view with the given offset and length, will handle the {@link Buffer} as well\n   *\n   * @see {@link https://nodejs.org/api/buffer.html#bufslicestart-end Buffer.slice}\n   */\n  slice<T extends ArrayBufferView>(o: T, start?: number, end?: number): T;\n\n  /**\n   * asView convert the given value to given {@link TypedArray} view\n   *\n   * TypedArray can be {@link Buffer}, will avoid copy\n   */\n  asView<C extends ArrayBufferViewConstructor<unknown>>(\n    TypedArray: C,\n    v: BufferSource,\n    byteOffset?: number,\n    byteLength?: number,\n  ): InstanceType<C>;\n\n  /**\n   * toString convert the given {@link BufferSource} to string\n   */\n  toString(v: BufferSource | string, encoding?: ToStringEncoding): string;\n\n  /**\n   * Returns true if encoding is the name of a supported character encoding, or false otherwise.\n   */\n  isEncoding(v?: string): v is ToStringEncoding;\n\n  toJSON<T = any>(v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any): T;\n\n  /**\n   * from convert the given value to {@link ArrayBuffer}\n   */\n  from(v: string | BufferSource, encoding?: ToStringEncoding): ArrayBuffer;\n\n  from<C extends ArrayBufferViewConstructor<unknown>>(\n    v: string | BufferSource,\n    encoding: ToStringEncoding,\n    TypedArray: C,\n  ): C;\n\n  /**\n   * concat the given {@link BufferSource} to a new {@link ArrayBuffer}\n   */\n  concat(buffers: Array<BufferSource>, result?: ArrayBuffer, offset?: number): ArrayBuffer;\n\n  fromBase64(v: string): Uint8Array;\n\n  fromHex(v: string): Uint8Array;\n\n  toBase64(v: BufferSource): string;\n\n  toHex(v: BufferSource): string;\n\n  resize(v: ArrayBuffer, newByteLength: number): ArrayBuffer;\n\n  // truncate(v: ArrayBufferLike, len?: number): ArrayBufferLike;\n}\n\ntype ToStringEncoding =\n  | 'ascii'\n  | 'utf16le'\n  // | 'utf-16le'\n  | 'ucs2'\n  | 'ucs-2'\n  | 'base64'\n  | 'base64url'\n  | 'latin1'\n  | 'binary'\n  | 'utf8'\n  | 'utf-8'\n  | 'hex';\n\nexport class ArrayBuffers {\n  static #nativeBufferAllowed: boolean = true;\n  static #isBufferAvailable: undefined | boolean;\n\n  static isNativeBufferAvailable() {\n    // eslint-disable-next-line no-return-assign\n    return (this.#isBufferAvailable ??= !(getGlobalThis().Buffer as any)?.isPollyfill?.());\n  }\n\n  static isNativeBufferAllowed() {\n    return this.#nativeBufferAllowed && this.#isBufferAvailable;\n  }\n\n  static setNativeBufferAllowed(v: boolean) {\n    this.#nativeBufferAllowed = v;\n  }\n\n  static isArrayBuffer = (v: any): v is ArrayBuffer => {\n    return v instanceof ArrayBuffer;\n  };\n\n  static toArrayBuffer(v: BufferSource): ArrayBuffer {\n    return v instanceof ArrayBuffer ? v : (v.buffer as ArrayBuffer);\n  }\n\n  static toUint8Array(v: BufferSource) {\n    return ArrayBuffers.asView(Uint8Array, v);\n  }\n\n  static toBase64 = (v: BufferSource) => {\n    if ('toBase64' in Uint8Array.prototype) {\n      return this.toUint8Array(v).toBase64();\n    }\n\n    if (ArrayBuffers.isNativeBufferAllowed()) {\n      return Buffer.from(ArrayBuffers.asView(Uint8Array, v)).toString('base64');\n    }\n\n    return encodeArrayBufferToBase64(this.toArrayBuffer(v));\n  };\n\n  static toHex = (v: BufferSource) => {\n    if ('toHex' in Uint8Array.prototype) {\n      return this.toUint8Array(v).toHex();\n    }\n    if (ArrayBuffers.isNativeBufferAllowed()) {\n      return Buffer.from(ArrayBuffers.asView(Uint8Array, v)).toString('hex');\n    }\n    return ArrayBuffers.toString(v, 'hex');\n  };\n\n  static fromBase64 = (v: string) => {\n    if ('fromBase64' in Uint8Array) {\n      return Uint8Array.fromBase64(v);\n    }\n    if (ArrayBuffers.isNativeBufferAllowed()) {\n      return Buffer.from(v, 'base64');\n    }\n    return this.toUint8Array(decodeBase64ToArrayBuffer(v));\n  };\n\n  static fromHex = (v: string) => {\n    if ('fromHex' in Uint8Array) {\n      return Uint8Array.fromHex(v);\n    }\n    return this.toUint8Array(ArrayBuffers.from(v, 'hex'));\n  };\n\n  static resize = (v: ArrayBuffer, newByteLength?: number, maxByteLength?: number): ArrayBuffer => {\n    if (newByteLength === undefined || newByteLength === null) {\n      return v;\n    }\n\n    // Chrome 111, Nodejs 20\n    if ('resize' in v && typeof v.resize === 'function') {\n      if ('resizable' in v && v.resizable) {\n        if ('maxByteLength' in v && typeof v.maxByteLength === 'number' && v.maxByteLength >= newByteLength) {\n          v.resize(newByteLength);\n          return v as ArrayBuffer;\n        }\n      }\n    }\n\n    const old = v;\n    const newBuf = new ArrayBuffer(newByteLength, { maxByteLength: maxByteLength });\n    const oldView = new Uint8Array(old);\n    const newView = new Uint8Array(newBuf);\n    newView.set(oldView);\n    return newBuf;\n  };\n\n  static slice = (o: TypedArray, start?: number, end?: number) => {\n    // NodeJS Buffer slice is not the same as UInt8Array slice\n    // https://nodejs.org/api/buffer.html#bufslicestart-end\n    if (isBuffer(o)) {\n      return Uint8Array.prototype.slice.call(o, start, end);\n    }\n    return o.slice(start, end);\n  };\n\n  static asView = <C extends ArrayBufferViewConstructor<unknown>, I extends InstanceType<C>>(\n    TypedArray: C,\n    v: BufferSource,\n    byteOffset?: number,\n    byteLength?: number,\n  ): I => {\n    if (v instanceof TypedArray && (byteOffset ?? 0) === 0 && byteLength === undefined) {\n      return v as I;\n    }\n    if (ArrayBuffer.isView(v) || isBuffer(v)) {\n      if (ArrayBuffers.isNativeBufferAllowed() && (TypedArray as any) === Buffer) {\n        // new Buffer() is deprecated\n        return Buffer.from(v.buffer, byteOffset, byteLength) as I;\n      }\n      return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength) as I;\n    }\n    return new TypedArray(v, byteOffset, byteLength) as I;\n  };\n\n  static toString = (buf: BufferSource | string, encoding: ToStringEncoding = 'utf8') => {\n    // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'\n    if (typeof buf === 'string') {\n      switch (encoding) {\n        case 'base64':\n          return btoa(buf);\n        case 'utf-8':\n        case 'utf8':\n          return buf;\n        default:\n          throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);\n      }\n    }\n    if (ArrayBuffers.isNativeBufferAllowed()) {\n      return Buffer.from(ArrayBuffers.asView(Uint8Array, buf)).toString(encoding);\n    }\n    // reference\n    // https://github.com/feross/buffer/blob/master/index.js\n    switch (encoding) {\n      case 'hex': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        return [...view].map((b) => hexLookupTable[b]).join('');\n      }\n      case 'base64': {\n        return encodeArrayBufferToBase64(ArrayBuffers.asView(Uint8Array, buf));\n      }\n      case 'utf8':\n      // falls through\n      case 'utf-8':\n        return new TextDecoder().decode(buf as any);\n      case 'ascii': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        return String.fromCharCode(...view.map((v) => v & 0x7f));\n      }\n      case 'latin1':\n      // falls through\n      case 'binary': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        return String.fromCharCode(...view);\n      }\n      case 'ucs2':\n      // falls through\n      case 'ucs-2':\n      // case 'utf-16le':\n      // falls through\n      case 'utf16le': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        let res = '';\n        // If length is odd, the last 8 bits must be ignored (same as node.js)\n        for (let i = 0; i < view.length - 1; i += 2) {\n          res += String.fromCharCode(view[i] + view[i + 1] * 256);\n        }\n        return res;\n      }\n      default:\n        throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${encoding}`);\n    }\n  };\n\n  static toJSON = (v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any) => {\n    return JSON.parse(ArrayBuffers.toString(v), reviver);\n  };\n\n  static alloc = (size: number, fill?: string | number, encoding?: ToStringEncoding) => {\n    if (fill !== undefined) {\n      if (typeof fill === 'number') {\n        return new Uint8Array(size).fill(fill);\n      }\n      // as cast\n      // https://stackoverflow.com/questions/73994091\n      return ArrayBuffers.asView(Uint8Array, ArrayBuffers.from(fill, encoding)).slice(0, size);\n    }\n    return new ArrayBuffer(size);\n  };\n\n  static from = (\n    v: string | BufferSource | ArrayLike<number> | Iterable<number>,\n    encoding: ToStringEncoding = 'utf8',\n    view?: any,\n  ): any => {\n    if (view) {\n      return this.asView(view, this.from(v, encoding));\n    }\n    if (!v) {\n      return new ArrayBuffer(0);\n    }\n    if (typeof v === 'string') {\n      if (ArrayBuffers.isNativeBufferAllowed()) {\n        return Buffer.from(v, encoding);\n      }\n\n      switch (encoding) {\n        case 'utf-8':\n        // falls through\n        case 'utf8':\n          return new TextEncoder().encode(v).buffer;\n        case 'base64':\n          // replaceAll need higher version of nodejs\n          return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));\n        case 'hex':\n          return new Uint8Array(v.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))).buffer;\n        default:\n          throw new Error(`[ArrayBuffers.from] Unknown encoding: ${encoding}`);\n      }\n    }\n    if (v instanceof ArrayBuffer) {\n      return v;\n    }\n    // lost length\n    if (ArrayBuffer.isView(v) || isBuffer(v)) {\n      if (v.byteOffset !== 0) {\n        // return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength)\n        throw new Error('ArrayBuffers.from do not support view with offset');\n      }\n      return v.buffer;\n    }\n    if (Array.isArray(v)) {\n      return new Uint8Array(v);\n    }\n    const type = classOf(v);\n    throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);\n  };\n\n  static isEncoding = (encoding?: string) => {\n    switch (String(encoding).toLowerCase()) {\n      case 'hex':\n      case 'utf8':\n      case 'utf-8':\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n      case 'base64':\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n        // case 'utf-16le':\n        return true;\n      default:\n        return false;\n    }\n  };\n\n  // static truncate = (a: ArrayBufferLike, len?: number) => {\n  //   if (len === 0) {\n  //     return new ArrayBuffer(0);\n  //   }\n  //   if (!len) {\n  //     return a;\n  //   }\n  //   if (a.byteLength > len) {\n  //     return a.slice(0, len);\n  //   } else if (a.byteLength < len) {\n  //     let b = new Uint8Array(len);\n  //     b.set(new Uint8Array(a));\n  //     return b;\n  //   }\n  //   return a;\n  // };\n\n  static concat = (buffers: Array<BufferSource>, result?: ArrayBuffer, offset = 0): ArrayBuffer => {\n    // https://stackoverflow.com/questions/10786128/appending-arraybuffers\n\n    const length = buffers.reduce((a, b) => a + b.byteLength, 0);\n    const r = result ? new Uint8Array(result) : new Uint8Array(length);\n    for (const buffer of buffers) {\n      if (!buffer?.byteLength) continue;\n      let n: Uint8Array;\n      if (buffer instanceof ArrayBuffer) {\n        n = new Uint8Array(buffer);\n      } else if (ArrayBuffer.isView(buffer)) {\n        n = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n      } else {\n        throw new Error(`ArrayBuffers.concat unsupported type ${classOf(buffer)}`);\n      }\n      r.set(n, offset);\n      offset += buffer.byteLength;\n    }\n    return r.buffer;\n  };\n}\n\nexport type TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | BigUint64Array\n  | BigInt64Array\n  | Float32Array\n  | Float64Array;\n\ntype ArrayBufferViewConstructor<T> = new (buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number) => T;\n\nconst hexLookupTable = (function () {\n  const alphabet = '0123456789abcdef';\n  const table = new Array(256);\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16;\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j];\n    }\n  }\n  return table;\n})();\n\ndeclare global {\n  interface ArrayBuffer {\n    resize?: (newByteLength: number) => void;\n    resizable?: boolean;\n  }\n\n  interface ArrayBufferConstructor {\n    new (byteLength: number, opts?: { maxByteLength?: number }): ArrayBuffer;\n  }\n\n  interface SharedArrayBuffer {\n    resize?: (newByteLength: number) => void;\n    resizable?: boolean;\n  }\n\n  interface Uint8Array {\n    toBase64(): string;\n\n    toHex(): string;\n  }\n\n  interface Uint8ArrayConstructor {\n    fromBase64(v: string): Uint8Array;\n\n    fromHex(v: string): Uint8Array;\n  }\n}\n"],"names":["classOf","getGlobalThis","decodeBase64ToArrayBuffer","encodeArrayBufferToBase64","isBuffer","ArrayBuffers","nativeBufferAllowed","isBufferAvailable","isNativeBufferAvailable","Buffer","isPollyfill","isNativeBufferAllowed","setNativeBufferAllowed","v","isArrayBuffer","ArrayBuffer","toArrayBuffer","buffer","toUint8Array","asView","Uint8Array","toBase64","prototype","from","toString","toHex","fromBase64","fromHex","resize","newByteLength","maxByteLength","undefined","resizable","old","newBuf","oldView","newView","set","slice","o","start","end","call","TypedArray","byteOffset","byteLength","isView","buf","encoding","btoa","Error","view","map","b","hexLookupTable","join","TextDecoder","decode","String","fromCharCode","res","i","length","toJSON","reviver","JSON","parse","alloc","size","fill","TextEncoder","encode","replace","match","byte","parseInt","Array","isArray","type","TypeError","isEncoding","toLowerCase","concat","buffers","result","offset","reduce","a","r","n","alphabet","table","i16","j"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../src/io/ArrayBuffers.ts"],"sourcesContent":["import { classOf } from '../langs/classOf';\nimport { getGlobalThis } from '../runtime/getGlobalThis';\nimport { decodeBase64ToUint8Array, encodeArrayBufferToBase64 } from './base64';\nimport { isBuffer } from './isBuffer';\n\n/**\n * Various utils to work with {@link ArrayBuffer}\n *\n * @see https://github.com/tc39/proposal-resizablearraybuffer\n */\nexport namespace ArrayBuffers {\n  /*\nUint8Array to/from base64 and hex\nStage 3\nUint8Array.fromBase64, Uint8Array.prototype.toBase64\nUint8Array.fromHex, Uint8Array.prototype.toHex\nhttps://github.com/tc39/proposal-arraybuffer-base64\n */\n\n  /*\nIn-Place Resizable and Growable ArrayBuffers\nStage 4\nChrome 111, Nodejs 20, Safari 16.4\n\nSharedArrayBuffer & ArrayBuffer\nconstructor(byteLength, {maxByteLength})\nprototype.resize(newByteLength)\nprototype.slice(start, end)\nprototype.{resizable,maxByteLength}\nhttps://github.com/tc39/proposal-resizablearraybuffer\n   */\n\n  export type BinaryStringEncoding =\n    | 'ascii'\n    | 'utf16le'\n    // | 'utf-16le'\n    | 'ucs2'\n    | 'ucs-2'\n    | 'base64'\n    | 'base64url'\n    | 'latin1'\n    | 'binary'\n    | 'utf8'\n    | 'utf-8'\n    | 'hex';\n\n  let nativeBufferAllowed: boolean = true;\n  let isBufferAvailable: undefined | boolean;\n\n  /**\n   * isNativeBufferAvailable check if the native {@link Buffer} is available\n   */\n  export function isNativeBufferAvailable(): boolean {\n    // eslint-disable-next-line no-return-assign\n    return (isBufferAvailable ??= !(getGlobalThis().Buffer as any)?.isPollyfill?.());\n  }\n\n  export function isNativeBufferAllowed(): boolean {\n    return Boolean(nativeBufferAllowed && isBufferAvailable);\n  }\n\n  export function setNativeBufferAllowed(v: boolean): void {\n    nativeBufferAllowed = v;\n  }\n\n  /**\n   * isArrayBuffer check if the given value is an {@link ArrayBuffer}\n   */\n  export function isArrayBuffer(v: any): v is ArrayBuffer {\n    return v instanceof ArrayBuffer;\n  }\n\n  /**\n   * slice the given view with the given offset and length, will handle the {@link Buffer} as well\n   *\n   * @see {@link https://nodejs.org/api/buffer.html#bufslicestart-end Buffer.slice}\n   */\n  export function slice<T extends TypedArray>(o: T, start?: number, end?: number): T {\n    // NodeJS Buffer slice is not the same as UInt8Array slice\n    // https://nodejs.org/api/buffer.html#bufslicestart-end\n    if (isBuffer(o)) {\n      return Uint8Array.prototype.slice.call(o, start, end) as T;\n    }\n    return o.slice(start, end) as T;\n  }\n\n  /**\n   * asView convert the given value to given {@link TypedArray} view\n   *\n   * TypedArray can be {@link Buffer}, will avoid copy\n   */\n  export function asView<C extends ArrayBufferViewConstructor<unknown>>(\n    TypedArray: C,\n    v: BufferSource,\n    byteOffset?: number,\n    byteLength?: number,\n  ): InstanceType<C> {\n    if (v instanceof TypedArray && (byteOffset ?? 0) === 0 && byteLength === undefined) {\n      return v as InstanceType<C>;\n    }\n    if (ArrayBuffer.isView(v) || isBuffer(v)) {\n      if (isNativeBufferAllowed() && (TypedArray as any) === Buffer) {\n        // new Buffer() is deprecated\n        return Buffer.from(v.buffer, byteOffset, byteLength) as InstanceType<C>;\n      }\n      return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength) as InstanceType<C>;\n    }\n    return new TypedArray(v, byteOffset, byteLength) as InstanceType<C>;\n  }\n\n  /**\n   * toString convert the given {@link BufferSource} to string\n   */\n  export function toString(source: BufferSource | string, encoding: BinaryStringEncoding = 'utf8'): string {\n    // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'\n    if (typeof source === 'string') {\n      switch (encoding) {\n        case 'base64':\n          return btoa(source);\n        case 'utf-8':\n        case 'utf8':\n          return source;\n        default:\n          throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);\n      }\n    }\n    let u8 = asView(Uint8Array, source);\n    if (isNativeBufferAllowed()) {\n      return Buffer.from(u8).toString(encoding);\n    }\n    // reference\n    // https://github.com/feross/buffer/blob/master/index.js\n    switch (encoding) {\n      case 'hex': {\n        return [...u8].map((b) => hexLookupTable[b]).join('');\n      }\n      case 'base64': {\n        return encodeArrayBufferToBase64(u8);\n      }\n      case 'utf8':\n      // falls through\n      case 'utf-8':\n        return new TextDecoder().decode(source);\n      case 'ascii': {\n        return String.fromCharCode(...u8.map((v) => v & 0x7f));\n      }\n      case 'latin1':\n      // falls through\n      case 'binary': {\n        return String.fromCharCode(...u8);\n      }\n      case 'ucs2':\n      // falls through\n      case 'ucs-2':\n      // case 'utf-16le':\n      // falls through\n      case 'utf16le': {\n        let res = '';\n        // If length is odd, the last 8 bits must be ignored (same as node.js)\n        for (let i = 0; i < u8.length - 1; i += 2) {\n          res += String.fromCharCode(u8[i] + u8[i + 1] * 256);\n        }\n        return res;\n      }\n      default:\n        throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${encoding}`);\n    }\n  }\n\n  function normalizeEncoding(encoding: string | undefined) {\n    switch (encoding?.toLowerCase()) {\n      case 'utf-8':\n      case 'utf8':\n        return 'utf8';\n      case 'utf-16le':\n      case 'ucs2':\n      case 'ucs-2':\n        return 'utf16le';\n      case 'hex':\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n      case 'base64':\n      case 'utf16le':\n        return encoding;\n      default:\n        return undefined;\n    }\n  }\n\n  /**\n   * Returns true if encoding is the name of a supported character encoding, or false otherwise.\n   */\n  export function isEncoding(v?: string): v is BinaryStringEncoding {\n    return normalizeEncoding(v) !== undefined;\n  }\n\n  export function toJSON<T = any>(v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any): T {\n    return JSON.parse(toString(v), reviver);\n  }\n\n  /**\n   * from convert the given value to {@link ArrayBuffer} like\n   */\n  export function from(\n    src: string | BufferSource | Array<number> | Iterable<number>,\n    encoding?: BinaryStringEncoding,\n  ): ArrayBuffer | TypedArray;\n  /**\n   * from convert the given value to {@link TypedArray}\n   */\n  export function from<C extends ArrayBufferViewConstructor<unknown>>(\n    src: string | BufferSource | Array<number> | Iterable<number>,\n    encoding: BinaryStringEncoding,\n    TypedArray: C,\n  ): InstanceType<C>;\n  export function from(\n    src: string | BufferSource | Array<number> | Iterable<number>,\n    encoding: BinaryStringEncoding = 'utf8',\n    view?: any,\n  ): any {\n    if (!src) {\n      return new (view || ArrayBuffer)(0);\n    }\n    if (isBufferSource(src)) {\n      return view ? asView(view, src) : src;\n    }\n    // Array<number> | Iterable<number>\n    if ((typeof src !== 'string' && isIterable(src)) || Array.isArray(src)) {\n      return (view || Uint8Array).from(src);\n    }\n    if (view) {\n      return asView(view, from(src, encoding));\n    }\n    if (typeof src === 'string') {\n      // is string\n      if (isNativeBufferAllowed()) {\n        return Buffer.from(src, encoding);\n      }\n      switch (encoding) {\n        case 'utf-8':\n        // falls through\n        case 'utf8':\n          return new TextEncoder().encode(src).buffer;\n        case 'base64':\n          // replaceAll need higher version of nodejs\n          // return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));\n          return fromBase64(src);\n        case 'hex':\n          // return new Uint8Array(v.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))).buffer;\n          return fromHex(src);\n        default:\n          throw new Error(`ArrayBuffers.from unsupported encoding: ${encoding}`);\n      }\n    }\n\n    const type = classOf(src);\n    throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);\n  }\n\n  /**\n   * concat the given {@link BufferSource} to a new {@link ArrayBuffer}\n   */\n  export function concat(buffers: Array<BufferSource>, result?: ArrayBuffer, offset = 0): ArrayBuffer {\n    // https://stackoverflow.com/questions/10786128/appending-arraybuffers\n\n    const length = buffers.reduce((a, b) => a + b.byteLength, 0);\n    const r = result ? new Uint8Array(result) : new Uint8Array(length);\n    for (const buffer of buffers) {\n      if (!buffer?.byteLength) continue;\n      let n: Uint8Array;\n      if (buffer instanceof ArrayBuffer) {\n        n = new Uint8Array(buffer);\n      } else if (ArrayBuffer.isView(buffer)) {\n        n = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n      } else {\n        throw new Error(`ArrayBuffers.concat unsupported type ${classOf(buffer)}`);\n      }\n      r.set(n, offset);\n      offset += buffer.byteLength;\n    }\n    return r.buffer;\n  }\n\n  export function fromBase64(v: string): Uint8Array {\n    if ('fromBase64' in Uint8Array) {\n      return Uint8Array.fromBase64(v);\n    }\n    if (isNativeBufferAllowed()) {\n      return Buffer.from(v, 'base64');\n    }\n    return decodeBase64ToUint8Array(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));\n  }\n\n  export function fromHex(v: string): Uint8Array {\n    if ('fromHex' in Uint8Array) {\n      return Uint8Array.fromHex(v);\n    }\n    if (isNativeBufferAllowed()) {\n      return Buffer.from(v, 'hex');\n    }\n    return new Uint8Array(v.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16)));\n  }\n\n  /**\n   * toBase64 convert the given {@link BufferSource} to base64 string\n   * @param source if string, will be encoded as utf8\n   */\n  export function toBase64(source: BufferSource | string): string {\n    if (typeof source === 'string') {\n      source = new TextEncoder().encode(source);\n    }\n    if ('toBase64' in Uint8Array.prototype) {\n      return toUint8Array(source).toBase64();\n    }\n    if (isNativeBufferAllowed()) {\n      return Buffer.from(asView(Uint8Array, source)).toString('base64');\n    }\n    return encodeArrayBufferToBase64(toArrayBuffer(source));\n  }\n\n  export function toHex(v: BufferSource): string {\n    if ('toHex' in Uint8Array.prototype) {\n      return toUint8Array(v).toHex();\n    }\n    if (isNativeBufferAllowed()) {\n      return Buffer.from(asView(Uint8Array, v)).toString('hex');\n    }\n    return toString(v, 'hex');\n  }\n\n  export function resize(v: ArrayBuffer, newByteLength?: number, maxByteLength?: number): ArrayBuffer {\n    if (newByteLength === undefined || newByteLength === null) {\n      return v;\n    }\n\n    // Chrome 111, Nodejs 20\n    if ('resize' in v && typeof v.resize === 'function') {\n      if ('resizable' in v && v.resizable) {\n        if ('maxByteLength' in v && typeof v.maxByteLength === 'number' && v.maxByteLength >= newByteLength) {\n          v.resize(newByteLength);\n          return v as ArrayBuffer;\n        }\n      }\n    }\n\n    const old = v;\n    const newBuf = new ArrayBuffer(newByteLength, { maxByteLength: maxByteLength });\n    const oldView = new Uint8Array(old);\n    const newView = new Uint8Array(newBuf);\n    newView.set(oldView);\n    return newBuf;\n  }\n\n  export function toArrayBuffer(v: BufferSource): ArrayBuffer {\n    if (v instanceof ArrayBuffer) {\n      return v;\n    }\n    if (ArrayBuffer.isView(v)) {\n      if (v.byteOffset > 0) {\n        throw new Error('ArrayBuffers.toArrayBuffer do not support view with offset');\n      }\n      return v.buffer;\n    }\n    throw new Error(`ArrayBuffers.toArrayBuffer unsupported type ${classOf(v)}`);\n  }\n\n  export function toUint8Array(v: BufferSource): Uint8Array {\n    return asView(Uint8Array, v);\n  }\n\n  export function alloc(size: number, fill?: string | number, encoding?: BinaryStringEncoding): ArrayBuffer {\n    if (fill !== undefined) {\n      if (typeof fill === 'number') {\n        return new Uint8Array(size).fill(fill);\n      }\n      // as cast\n      // https://stackoverflow.com/questions/73994091\n      return asView(Uint8Array, from(fill, encoding)).slice(0, size);\n    }\n    return new ArrayBuffer(size);\n  }\n}\n\nexport type TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | BigUint64Array\n  | BigInt64Array\n  | Float32Array\n  | Float64Array;\n\ntype ArrayBufferViewConstructor<T> = new (buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number) => T;\n\nconst hexLookupTable = (function () {\n  const alphabet = '0123456789abcdef';\n  const table = new Array(256);\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16;\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j];\n    }\n  }\n  return table;\n})();\n\ndeclare global {\n  interface ArrayBuffer {\n    resize?: (newByteLength: number) => void;\n    resizable?: boolean;\n  }\n\n  interface ArrayBufferConstructor {\n    new (byteLength: number, opts?: { maxByteLength?: number }): ArrayBuffer;\n  }\n\n  interface SharedArrayBuffer {\n    resize?: (newByteLength: number) => void;\n    resizable?: boolean;\n  }\n\n  interface Uint8Array {\n    toBase64(): string;\n\n    toHex(): string;\n  }\n\n  interface Uint8ArrayConstructor {\n    fromBase64(v: string): Uint8Array;\n\n    fromHex(v: string): Uint8Array;\n  }\n}\n\nfunction isIterable(obj: any): obj is Iterable<any> {\n  return typeof obj?.[Symbol.iterator] === 'function';\n}\n\nfunction isBufferSource(v: any): v is BufferSource {\n  return ArrayBuffer.isView(v) || v instanceof ArrayBuffer;\n}\n"],"names":["classOf","getGlobalThis","decodeBase64ToUint8Array","encodeArrayBufferToBase64","isBuffer","ArrayBuffers","nativeBufferAllowed","isBufferAvailable","isNativeBufferAvailable","Buffer","isPollyfill","isNativeBufferAllowed","Boolean","setNativeBufferAllowed","v","isArrayBuffer","ArrayBuffer","slice","o","start","end","Uint8Array","prototype","call","asView","TypedArray","byteOffset","byteLength","undefined","isView","from","buffer","toString","source","encoding","btoa","Error","u8","map","b","hexLookupTable","join","TextDecoder","decode","String","fromCharCode","res","i","length","normalizeEncoding","toLowerCase","isEncoding","toJSON","reviver","JSON","parse","src","view","isBufferSource","isIterable","Array","isArray","TextEncoder","encode","fromBase64","fromHex","type","TypeError","concat","buffers","result","offset","reduce","a","r","n","set","replace","match","byte","parseInt","toBase64","toUint8Array","toArrayBuffer","toHex","resize","newByteLength","maxByteLength","resizable","old","newBuf","oldView","newView","alloc","size","fill","alphabet","table","i16","j","obj","Symbol","iterator"],"mappings":"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"}

package/lib/io/Buffer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/io/Buffer.ts"],"sourcesContent":["import { ArrayBuffers } from './ArrayBuffers';\nimport { isBuffer } from './isBuffer';\n\n/**\n * Buffer is a polyfill version of NodeJS Buffer\n */\nexport class Buffer extends Uint8Array {\n  // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {\n  //   super(buffer, byteOffset, length);\n  // }\n\n  static get isPolyfill() {\n    return true;\n  }\n\n  static isBuffer(v: any): v is Buffer {\n    return v instanceof Buffer || isBuffer(v);\n  }\n\n  static from(array: string | BufferSource | ArrayLike<number> | Iterable<number>, arg2?: any): Buffer {\n    // todo mapfn\n    return new Buffer(ArrayBuffers.from(array, arg2) as ArrayBuffer);\n  }\n\n  static isEncoding = ArrayBuffers.isEncoding;\n\n  toString(encoding?: string): string {\n    return ArrayBuffers.toString(this, encoding as any);\n  }\n}\n"],"names":["ArrayBuffers","isBuffer","Buffer","Uint8Array","isPolyfill","v","from","array","arg2","isEncoding","toString","encoding"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,YAAY,QAAQ,iBAAiB;AAC9C,SAASC,QAAQ,QAAQ,aAAa;AAEtC;;CAEC,GACD,OAAO,MAAMC,eAAeC;IAC1B,+EAA+E;IAC/E,uCAAuC;IACvC,IAAI;IAEJ,WAAWC,aAAa;QACtB,OAAO;IACT;IAEA,OAAOH,SAASI,CAAM,EAAe;QACnC,OAAOA,aAAaH,UAAUD,SAASI;IACzC;IAEA,OAAOC,KAAKC,KAAmE,EAAEC,IAAU,EAAU;QACnG,aAAa;QACb,OAAO,IAAIN,OAAOF,aAAaM,IAAI,CAACC,OAAOC;IAC7C;IAEA,OAAOC,aAAaT,aAAaS,UAAU,CAAC;IAE5CC,SAASC,QAAiB,EAAU;QAClC,OAAOX,aAAaU,QAAQ,CAAC,IAAI,EAAEC;IACrC;AACF"}
+{"version":3,"sources":["../../src/io/Buffer.ts"],"sourcesContent":["import { ArrayBuffers } from './ArrayBuffers';\nimport { isBuffer } from './isBuffer';\n\n/**\n * Buffer is a polyfill version of NodeJS Buffer\n */\nexport class Buffer extends Uint8Array {\n  // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {\n  //   super(buffer, byteOffset, length);\n  // }\n\n  static get isPolyfill() {\n    return true;\n  }\n\n  static isBuffer(v: any): v is Buffer {\n    return v instanceof Buffer || isBuffer(v);\n  }\n\n  static from(array: string | BufferSource | ArrayLike<number> | Iterable<number>, arg2?: any): Buffer {\n    // todo mapfn\n    return new Buffer(ArrayBuffers.from(array, arg2) as ArrayBuffer);\n  }\n\n  static isEncoding = ArrayBuffers.isEncoding;\n\n  toString(encoding?: string): string {\n    return ArrayBuffers.toString(this, encoding as any);\n  }\n}\n"],"names":["ArrayBuffers","isBuffer","Buffer","Uint8Array","isPolyfill","v","from","array","arg2","isEncoding","toString","encoding"],"mappings":"AAAA,SAASA,YAAY,QAAQ,iBAAiB;AAC9C,SAASC,QAAQ,QAAQ,aAAa;AAEtC;;CAEC,GACD,OAAO,MAAMC,eAAeC;IAC1B,+EAA+E;IAC/E,uCAAuC;IACvC,IAAI;IAEJ,WAAWC,aAAa;QACtB,OAAO;IACT;IAEA,OAAOH,SAASI,CAAM,EAAe;QACnC,OAAOA,aAAaH,UAAUD,SAASI;IACzC;IAEA,OAAOC,KAAKC,KAAmE,EAAEC,IAAU,EAAU;QACnG,aAAa;QACb,OAAO,IAAIN,OAAOF,aAAaM,IAAI,CAACC,OAAOC;IAC7C;IAEA,OAAOC,aAAaT,aAAaS,UAAU,CAAC;IAE5CC,SAASC,QAAiB,EAAU;QAClC,OAAOX,aAAaU,QAAQ,CAAC,IAAI,EAAEC;IACrC;AACF"}