@wener/utils 1.1.49 → 1.1.50

package/src/io/ArrayBuffers.ts

@@ -1,252 +1,153 @@
 import { classOf } from '../langs/classOf';
 import { getGlobalThis } from '../runtime/getGlobalThis';
-import { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64';
+import { decodeBase64ToUint8Array, encodeArrayBufferToBase64 } from './base64';
 import { isBuffer } from './isBuffer';
 
 /**
  * Various utils to work with {@link ArrayBuffer}
  *
- * @see https://github.com/tc39/proposal-arraybuffer-base64
  * @see https://github.com/tc39/proposal-resizablearraybuffer
  */
-export interface ArrayBuffers {
-  /**
-   * isArrayBuffer check if the given value is an {@link ArrayBuffer}
-   */
-  isArrayBuffer(v: any): v is 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}
-   */
-  slice<T extends ArrayBufferView>(o: T, start?: number, end?: number): T;
-
-  /**
-   * asView convert the given value to given {@link TypedArray} view
-   *
-   * TypedArray can be {@link Buffer}, will avoid copy
-   */
-  asView<C extends ArrayBufferViewConstructor<unknown>>(
-    TypedArray: C,
-    v: BufferSource,
-    byteOffset?: number,
-    byteLength?: number,
-  ): InstanceType<C>;
-
-  /**
-   * toString convert the given {@link BufferSource} to string
-   */
-  toString(v: BufferSource | string, encoding?: ToStringEncoding): string;
-
-  /**
-   * Returns true if encoding is the name of a supported character encoding, or false otherwise.
-   */
-  isEncoding(v?: string): v is ToStringEncoding;
-
-  toJSON<T = any>(v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any): T;
+export namespace ArrayBuffers {
+  /*
+Uint8Array to/from base64 and hex
+Stage 3
+Uint8Array.fromBase64, Uint8Array.prototype.toBase64
+Uint8Array.fromHex, Uint8Array.prototype.toHex
+https://github.com/tc39/proposal-arraybuffer-base64
+ */
 
-  /**
-   * from convert the given value to {@link ArrayBuffer}
+  /*
+In-Place Resizable and Growable ArrayBuffers
+Stage 4
+Chrome 111, Nodejs 20, Safari 16.4
+
+SharedArrayBuffer & ArrayBuffer
+constructor(byteLength, {maxByteLength})
+prototype.resize(newByteLength)
+prototype.slice(start, end)
+prototype.{resizable,maxByteLength}
+https://github.com/tc39/proposal-resizablearraybuffer
    */
-  from(v: string | BufferSource, encoding?: ToStringEncoding): ArrayBuffer;
 
-  from<C extends ArrayBufferViewConstructor<unknown>>(
-    v: string | BufferSource,
-    encoding: ToStringEncoding,
-    TypedArray: C,
-  ): C;
+  export type BinaryStringEncoding =
+    | 'ascii'
+    | 'utf16le'
+    // | 'utf-16le'
+    | 'ucs2'
+    | 'ucs-2'
+    | 'base64'
+    | 'base64url'
+    | 'latin1'
+    | 'binary'
+    | 'utf8'
+    | 'utf-8'
+    | 'hex';
+
+  let nativeBufferAllowed: boolean = true;
+  let isBufferAvailable: undefined | boolean;
 
   /**
-   * concat the given {@link BufferSource} to a new {@link ArrayBuffer}
+   * isNativeBufferAvailable check if the native {@link Buffer} is available
    */
-  concat(buffers: Array<BufferSource>, result?: ArrayBuffer, offset?: number): ArrayBuffer;
-
-  fromBase64(v: string): Uint8Array;
-
-  fromHex(v: string): Uint8Array;
-
-  toBase64(v: BufferSource): string;
-
-  toHex(v: BufferSource): string;
-
-  resize(v: ArrayBuffer, newByteLength: number): ArrayBuffer;
-
-  // truncate(v: ArrayBufferLike, len?: number): ArrayBufferLike;
-}
-
-type ToStringEncoding =
-  | 'ascii'
-  | 'utf16le'
-  // | 'utf-16le'
-  | 'ucs2'
-  | 'ucs-2'
-  | 'base64'
-  | 'base64url'
-  | 'latin1'
-  | 'binary'
-  | 'utf8'
-  | 'utf-8'
-  | 'hex';
-
-export class ArrayBuffers {
-  static #nativeBufferAllowed: boolean = true;
-  static #isBufferAvailable: undefined | boolean;
-
-  static isNativeBufferAvailable() {
+  export function isNativeBufferAvailable(): boolean {
     // eslint-disable-next-line no-return-assign
-    return (this.#isBufferAvailable ??= !(getGlobalThis().Buffer as any)?.isPollyfill?.());
+    return (isBufferAvailable ??= !(getGlobalThis().Buffer as any)?.isPollyfill?.());
   }
 
-  static isNativeBufferAllowed() {
-    return this.#nativeBufferAllowed && this.#isBufferAvailable;
+  export function isNativeBufferAllowed(): boolean {
+    return Boolean(nativeBufferAllowed && isBufferAvailable);
   }
 
-  static setNativeBufferAllowed(v: boolean) {
-    this.#nativeBufferAllowed = v;
+  export function setNativeBufferAllowed(v: boolean): void {
+    nativeBufferAllowed = v;
   }
 
-  static isArrayBuffer = (v: any): v is ArrayBuffer => {
+  /**
+   * isArrayBuffer check if the given value is an {@link ArrayBuffer}
+   */
+  export function isArrayBuffer(v: any): v is ArrayBuffer {
     return v instanceof ArrayBuffer;
-  };
-
-  static toArrayBuffer(v: BufferSource): ArrayBuffer {
-    return v instanceof ArrayBuffer ? v : (v.buffer as ArrayBuffer);
   }
 
-  static toUint8Array(v: BufferSource) {
-    return ArrayBuffers.asView(Uint8Array, v);
-  }
-
-  static toBase64 = (v: BufferSource) => {
-    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: BufferSource) => {
-    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: string) => {
-    if ('fromBase64' in Uint8Array) {
-      return Uint8Array.fromBase64(v);
-    }
-    if (ArrayBuffers.isNativeBufferAllowed()) {
-      return Buffer.from(v, 'base64');
-    }
-    return this.toUint8Array(decodeBase64ToArrayBuffer(v));
-  };
-
-  static fromHex = (v: string) => {
-    if ('fromHex' in Uint8Array) {
-      return Uint8Array.fromHex(v);
-    }
-    return this.toUint8Array(ArrayBuffers.from(v, 'hex'));
-  };
-
-  static resize = (v: ArrayBuffer, newByteLength?: number, maxByteLength?: number): ArrayBuffer => {
-    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 as ArrayBuffer;
-        }
-      }
-    }
-
-    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: TypedArray, start?: number, end?: number) => {
+  /**
+   * 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<T extends TypedArray>(o: T, start?: number, end?: number): T {
     // 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 Uint8Array.prototype.slice.call(o, start, end) as T;
     }
-    return o.slice(start, end);
-  };
+    return o.slice(start, end) as T;
+  }
 
-  static asView = <C extends ArrayBufferViewConstructor<unknown>, I extends InstanceType<C>>(
+  /**
+   * asView convert the given value to given {@link TypedArray} view
+   *
+   * TypedArray can be {@link Buffer}, will avoid copy
+   */
+  export function asView<C extends ArrayBufferViewConstructor<unknown>>(
     TypedArray: C,
     v: BufferSource,
     byteOffset?: number,
     byteLength?: number,
-  ): I => {
+  ): InstanceType<C> {
     if (v instanceof TypedArray && (byteOffset ?? 0) === 0 && byteLength === undefined) {
-      return v as I;
+      return v as InstanceType<C>;
     }
     if (ArrayBuffer.isView(v) || isBuffer(v)) {
-      if (ArrayBuffers.isNativeBufferAllowed() && (TypedArray as any) === Buffer) {
+      if (isNativeBufferAllowed() && (TypedArray as any) === Buffer) {
         // new Buffer() is deprecated
-        return Buffer.from(v.buffer, byteOffset, byteLength) as I;
+        return Buffer.from(v.buffer, byteOffset, byteLength) as InstanceType<C>;
       }
-      return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength) as I;
+      return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength) as InstanceType<C>;
     }
-    return new TypedArray(v, byteOffset, byteLength) as I;
-  };
+    return new TypedArray(v, byteOffset, byteLength) as InstanceType<C>;
+  }
 
-  static toString = (buf: BufferSource | string, encoding: ToStringEncoding = 'utf8') => {
+  /**
+   * toString convert the given {@link BufferSource} to string
+   */
+  export function toString(source: BufferSource | string, encoding: BinaryStringEncoding = 'utf8'): string {
     // '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: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
-        return [...view].map((b) => hexLookupTable[b]).join('');
+        return [...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 as any);
+        return new TextDecoder().decode(source);
       case 'ascii': {
-        const view: Uint8Array = 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: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
-        return String.fromCharCode(...view);
+        return String.fromCharCode(...u8);
       }
       case 'ucs2':
       // falls through
@@ -254,120 +155,113 @@ export class ArrayBuffers {
       // case 'utf-16le':
       // falls through
       case 'utf16le': {
-        const view: Uint8Array = 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: BufferSource | string, reviver?: (this: any, key: string, value: any) => any) => {
-    return JSON.parse(ArrayBuffers.toString(v), reviver);
-  };
+  }
 
-  static alloc = (size: number, fill?: string | number, encoding?: ToStringEncoding) => {
-    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);
+  function normalizeEncoding(encoding: string | undefined) {
+    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: string | BufferSource | ArrayLike<number> | Iterable<number>,
-    encoding: ToStringEncoding = 'utf8',
+  /**
+   * Returns true if encoding is the name of a supported character encoding, or false otherwise.
+   */
+  export function isEncoding(v?: string): v is BinaryStringEncoding {
+    return normalizeEncoding(v) !== undefined;
+  }
+
+  export function toJSON<T = any>(v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any): T {
+    return JSON.parse(toString(v), reviver);
+  }
+
+  /**
+   * from convert the given value to {@link ArrayBuffer} like
+   */
+  export function from(
+    src: string | BufferSource | Array<number> | Iterable<number>,
+    encoding?: BinaryStringEncoding,
+  ): ArrayBuffer | TypedArray;
+  /**
+   * from convert the given value to {@link TypedArray}
+   */
+  export function from<C extends ArrayBufferViewConstructor<unknown>>(
+    src: string | BufferSource | Array<number> | Iterable<number>,
+    encoding: BinaryStringEncoding,
+    TypedArray: C,
+  ): InstanceType<C>;
+  export function from(
+    src: string | BufferSource | Array<number> | Iterable<number>,
+    encoding: BinaryStringEncoding = 'utf8',
     view?: any,
-  ): any => {
-    if (view) {
-      return this.asView(view, this.from(v, encoding));
+  ): any {
+    if (!src) {
+      return new (view || ArrayBuffer)(0);
+    }
+    if (isBufferSource(src)) {
+      return view ? asView(view, src) : src;
     }
-    if (!v) {
-      return new ArrayBuffer(0);
+    // Array<number> | Iterable<number>
+    if ((typeof src !== 'string' && isIterable(src)) || Array.isArray(src)) {
+      return (view || Uint8Array).from(src);
     }
-    if (typeof v === 'string') {
-      if (ArrayBuffers.isNativeBufferAllowed()) {
-        return Buffer.from(v, encoding);
+    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}`);
+          throw new Error(`ArrayBuffers.from unsupported 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');
-      }
-      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?: string) => {
-    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: Array<BufferSource>, result?: ArrayBuffer, offset = 0): ArrayBuffer => {
+  /**
+   * concat the given {@link BufferSource} to a new {@link ArrayBuffer}
+   */
+  export function concat(buffers: Array<BufferSource>, result?: ArrayBuffer, offset = 0): ArrayBuffer {
     // https://stackoverflow.com/questions/10786128/appending-arraybuffers
 
     const length = buffers.reduce((a, b) => a + b.byteLength, 0);
@@ -386,7 +280,106 @@ export class ArrayBuffers {
       offset += buffer.byteLength;
     }
     return r.buffer;
-  };
+  }
+
+  export function fromBase64(v: string): Uint8Array {
+    if ('fromBase64' in Uint8Array) {
+      return Uint8Array.fromBase64(v);
+    }
+    if (isNativeBufferAllowed()) {
+      return Buffer.from(v, 'base64');
+    }
+    return decodeBase64ToUint8Array(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
+  }
+
+  export function fromHex(v: string): Uint8Array {
+    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)));
+  }
+
+  /**
+   * toBase64 convert the given {@link BufferSource} to base64 string
+   * @param source if string, will be encoded as utf8
+   */
+  export function toBase64(source: BufferSource | string): string {
+    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));
+  }
+
+  export function toHex(v: BufferSource): string {
+    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: ArrayBuffer, newByteLength?: number, maxByteLength?: number): ArrayBuffer {
+    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 as ArrayBuffer;
+        }
+      }
+    }
+
+    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;
+  }
+
+  export function toArrayBuffer(v: BufferSource): ArrayBuffer {
+    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)}`);
+  }
+
+  export function toUint8Array(v: BufferSource): Uint8Array {
+    return asView(Uint8Array, v);
+  }
+
+  export function alloc(size: number, fill?: string | number, encoding?: BinaryStringEncoding): ArrayBuffer {
+    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);
+  }
 }
 
 export type TypedArray =
@@ -443,3 +436,11 @@ declare global {
     fromHex(v: string): Uint8Array;
   }
 }
+
+function isIterable(obj: any): obj is Iterable<any> {
+  return typeof obj?.[Symbol.iterator] === 'function';
+}
+
+function isBufferSource(v: any): v is BufferSource {
+  return ArrayBuffer.isView(v) || v instanceof ArrayBuffer;
+}

package/src/io/base64.ts

@@ -29,7 +29,7 @@ export function encodeArrayBufferToBase64(arraybuffer: ArrayBuffer): string {
   return base64;
 }
 
-export function decodeBase64ToArrayBuffer(base64: string): ArrayBuffer {
+export function decodeBase64ToUint8Array(base64: string): Uint8Array {
   const len = base64.length;
   let bufferLength = base64.length * 0.75;
   let i;
@@ -60,5 +60,5 @@ export function decodeBase64ToArrayBuffer(base64: string): ArrayBuffer {
     bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
   }
 
-  return arraybuffer;
+  return bytes;
 }

package/src/langs/getObjectId.ts

@@ -3,7 +3,7 @@ import { getGlobalStates } from './getGlobalStates';
 export function getObjectId(k: any): number {
   const state = getGlobalStates('ObjectId', () => {
     return {
-      id: 0,
+      id: 1,
       map: new WeakMap(),
     };
   });