@wener/utils 1.1.48 → 1.1.50

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: ArrayBufferLike, 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;\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) => {\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 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"}

package/lib/io/ByteBuffer.js

@@ -29,17 +29,35 @@ function asBuffer(o) {
 /**
  * @see {@link https://www.egret.uk/docs/egretengine/engine/egret.ByteArray egret.ByteArray}
  * @see {@link https://github.com/protobufjs/bytebuffer.js protobufjs/bytebuffer.js}
- * @see {@link https://netty.io/4.1/api/io/netty/buffer/ByteBuf.html ByteBuf}
+ * @see {@link https://netty.io/4.1/api/io/netty/buffer/ByteBuf.html io.netty.buffer.ByteBuf}
+ * @see {@link https://nodejs.org/api/buffer.html node:buffer}
+ * @see {@link https://www.postgresql.org/docs/current/datatype.html PostgreSQL Data Types}
  */ export class ByteBuffer {
     position = 0;
     #buffer;
     #view;
+    #bytes;
+    // #endian: 'big' | 'little' = 'big';
+    #bigEndian = true;
     constructor(buffer = new ArrayBuffer(0, {
         maxByteLength: 1024
     })){
         this.#buffer = asBuffer(buffer);
         // NOTE prefer view over buffer, avoid the slice overhead ?
         this.#view = new DataView(this.#buffer);
+        this.#bytes = new Uint8Array(this.#buffer);
+    }
+    get littleEndian() {
+        return !this.#bigEndian;
+    }
+    set littleEndian(v) {
+        this.#bigEndian = !v;
+    }
+    get bigEndian() {
+        return this.#bigEndian;
+    }
+    set bigEndian(v) {
+        this.#bigEndian = v;
     }
     get view() {
         return this.#view;
@@ -50,6 +68,10 @@ function asBuffer(o) {
     set buffer(buffer) {
         this.#buffer = asBuffer(buffer);
         this.#view = new DataView(this.#buffer);
+        this.#bytes = new Uint8Array(this.#buffer);
+    }
+    get bytes() {
+        return this.#bytes;
     }
     get length() {
         return this.view.byteLength;
@@ -57,12 +79,8 @@ function asBuffer(o) {
     set length(length) {
         this.resize(length);
     }
-    willWrite(length) {
-        if (this.remaining() < length) {
-            this.resize(this.position + length);
-        }
-    }
     resize(newLength) {
+        // 1.2 for buffer growth
         this.buffer = ArrayBuffers.resize(this.buffer, newLength, Math.ceil(newLength * 1.2));
     }
     writeByte(value) {
@@ -71,8 +89,12 @@ function asBuffer(o) {
     }
     writeBytes(bytes, len = bytes.byteLength) {
         this.willWrite(len);
-        if (len !== bytes.byteLength) bytes = bytes.slice(0, len);
-        new Uint8Array(this.buffer).set(new Uint8Array(bytes), this.position);
+        // ensure len first
+        this.bytes.set(new Uint8Array(bytes).subarray(0, len), this.position);
+        if (len > bytes.byteLength) {
+            // fill zero
+            this.bytes.fill(0, this.position + bytes.byteLength, this.position + len);
+        }
         this.position += len;
     }
     writeInt8(value) {
@@ -87,52 +109,71 @@ function asBuffer(o) {
     }
     writeInt16(value) {
         this.willWrite(2);
-        this.view.setInt16(this.position, value);
+        this.view.setInt16(this.position, value, this.littleEndian);
         this.position += 2;
     }
     writeUint16(value) {
         this.willWrite(2);
-        this.view.setUint16(this.position, value);
+        this.view.setUint16(this.position, value, this.littleEndian);
         this.position += 2;
     }
+    writeUint24(value) {
+        this.willWrite(3);
+        this.view.setUint8(this.position, value & 0xff);
+        this.view.setUint16(this.position + 1, value >> 8, this.littleEndian);
+        this.position += 3;
+    }
     writeInt32(value) {
         this.willWrite(4);
-        this.view.setInt32(this.position, value);
+        this.view.setInt32(this.position, value, this.littleEndian);
         this.position += 4;
     }
     writeUint32(value) {
         this.willWrite(4);
-        this.view.setUint32(this.position, value);
+        this.view.setUint32(this.position, value, this.littleEndian);
         this.position += 4;
     }
     writeInt64(value) {
         this.willWrite(8);
-        this.view.setBigInt64(this.position, value);
+        this.view.setBigInt64(this.position, bigintOf(value), this.littleEndian);
         this.position += 8;
     }
     writeUint64(value) {
         this.willWrite(8);
-        this.view.setBigUint64(this.position, value);
+        this.view.setBigUint64(this.position, bigintOf(value), this.littleEndian);
         this.position += 8;
     }
     writeFloat32(value) {
         this.willWrite(4);
-        this.view.setFloat32(this.position, value);
+        this.view.setFloat32(this.position, value, this.littleEndian);
         this.position += 4;
     }
     writeFloat64(value) {
         this.willWrite(8);
-        this.view.setFloat64(this.position, value);
+        this.view.setFloat64(this.position, value, this.littleEndian);
         this.position += 8;
     }
     writeBoolean(value) {
         this.writeByte(value ? 1 : 0);
     }
     writeString(value, len) {
-        let encoder = new TextEncoder();
-        let bytes = encoder.encode(value);
+        let bytes = this.encodeText(value);
         this.writeBytes(bytes, len);
     }
+    readSizeString(n) {
+        return this.readString(requireNumber(this.readUint(n)));
+    }
+    writeSizeString(value, n) {
+        let out = this.encodeText(value);
+        this.writeUint(out.length, n);
+        this.writeBytes(out);
+    }
+    encodeText(value) {
+        return new TextEncoder().encode(value);
+    }
+    decodeText(bytes) {
+        return new TextDecoder().decode(bytes);
+    }
     readByte() {
         return this.view.getUint8(this.position++);
     }
@@ -151,72 +192,101 @@ function asBuffer(o) {
         this.position += 1;
         return value;
     }
+    readUnsignedByte() {
+        return this.readUint8();
+    }
+    readThrough(end) {
+        // readUntil 不包含 end
+        let idx = this.bytes.indexOf(end, this.position);
+        if (idx === -1) {
+            throw new Error(`Byte ${end} not found starting from position ${this.position}`);
+        }
+        let bytes = this.buffer.slice(this.position, idx + 1);
+        this.position = idx + 1;
+        return bytes;
+    }
     readInt16() {
-        let value = this.view.getInt16(this.position);
+        let value = this.view.getInt16(this.position, this.littleEndian);
         this.position += 2;
         return value;
     }
     readUint16() {
-        let value = this.view.getUint16(this.position);
+        let value = this.view.getUint16(this.position, this.littleEndian);
         this.position += 2;
         return value;
     }
     readInt32() {
-        let value = this.view.getInt32(this.position);
+        let value = this.view.getInt32(this.position, this.littleEndian);
         this.position += 4;
         return value;
     }
     readUint32() {
-        let value = this.view.getUint32(this.position);
+        let value = this.view.getUint32(this.position, this.littleEndian);
         this.position += 4;
         return value;
     }
     readInt64() {
-        let value = this.view.getBigInt64(this.position);
+        let value = this.view.getBigInt64(this.position, this.littleEndian);
         this.position += 8;
         return safeNumber(value);
     }
     readUint64() {
-        let value = this.view.getBigUint64(this.position);
+        let value = this.view.getBigUint64(this.position, this.littleEndian);
         this.position += 8;
         return safeNumber(value);
     }
     readFloat32() {
-        let value = this.view.getFloat32(this.position);
+        let value = this.view.getFloat32(this.position, this.littleEndian);
         this.position += 4;
         return value;
     }
     readFloat64() {
-        let value = this.view.getFloat64(this.position);
+        let value = this.view.getFloat64(this.position, this.littleEndian);
         this.position += 8;
         return value;
     }
     readBoolean() {
+        // or !== 0?
         return this.readByte() === 1;
     }
     readString(length) {
         let bytes = this.readBytes(length);
-        let decoder = new TextDecoder();
         let a = new Uint8Array(bytes);
         let idx = a.indexOf(0);
         if (idx !== -1) {
             bytes = bytes.slice(0, idx);
         }
-        return decoder.decode(bytes);
+        return this.decodeText(bytes);
     }
     readHexString(length) {
         let bytes = this.readBytes(length);
         return ArrayBuffers.toHex(bytes);
     }
+    writeHexString(value, len) {
+        this.writeBytes(ArrayBuffers.fromHex(value), len);
+    }
     writeInt24(value) {
+        // fixme byte order
         this.writeUint8(value & 0xff);
         this.writeUint16(value >> 8);
     }
     readInt24() {
-        return this.readUint8() | this.readUint16() << 8;
+        // fixme recheck
+        let value = this.readUint24();
+        if (value & 0x800000) {
+            // If the sign bit is set, extend the sign
+            value |= 0xff000000;
+        }
+        return value;
+    }
+    readUint24() {
+        // fixme recheck
+        return this.readUint8() | this.readUint8() << 8 | this.readUint8() << 16;
     }
     writeZero(length) {
-        this.writeBytes(new Uint8Array(length).buffer);
+        this.willWrite(length);
+        this.bytes.fill(0, this.position, this.position + length);
+        this.position += length;
     }
     writeValue(a, b) {
         const tv = typeof a === 'string' ? {
@@ -238,16 +308,26 @@ function asBuffer(o) {
             case 'int16':
                 this.writeInt16(value);
                 break;
+            case 'uint24':
+                this.writeUint24(value);
+                break;
+            case 'int24':
+                this.writeInt24(value);
+                break;
             case 'uint32':
+            case 'uint':
                 this.writeUint32(value);
                 break;
             case 'int32':
+            case 'int':
                 this.writeInt32(value);
                 break;
             case 'float32':
+            case 'float':
                 this.writeFloat32(value);
                 break;
             case 'float64':
+            case 'double':
                 this.writeFloat64(value);
                 break;
             case 'string':
@@ -263,18 +343,120 @@ function asBuffer(o) {
                 throw new Error(`Unknown type ${type}`);
         }
     }
-    readInt() {
-        return this.readInt32();
+    readUnsignedShort() {
+        return this.readUint16();
+    }
+    readShort() {
+        return this.readInt16();
+    }
+    readInt(bytesOrBits = 32) {
+        switch(bytesOrBits){
+            case 1:
+            case 8:
+                return this.readInt8();
+            case 2:
+            case 16:
+                return this.readInt16();
+            case 3:
+            case 24:
+                return this.readInt24();
+            case 4:
+            case 32:
+                return this.readInt32();
+            // skip 8 byte for bits
+            case 64:
+                return this.readInt64();
+            default:
+                throw new Error(`Unknown int${bytesOrBits}`);
+        }
     }
-    readFloat() {
-        return this.readFloat32();
+    readUint(bytesOrBits = 32) {
+        switch(bytesOrBits){
+            case 1:
+            case 8:
+                return this.readUint8();
+            case 2:
+            case 16:
+                return this.readUint16();
+            case 3:
+            case 24:
+                return this.readUint24();
+            case 4:
+            case 32:
+                return this.readUint32();
+            // skip 8 byte for bits
+            case 64:
+                return this.readUint64();
+            default:
+                throw new Error(`Unexpected int size: ${bytesOrBits}`);
+        }
+    }
+    writeUint(value, bytesOrBits = 32) {
+        switch(bytesOrBits){
+            case 1:
+            case 8:
+                this.writeUint8(value);
+                break;
+            case 2:
+            case 16:
+                this.writeUint16(value);
+                break;
+            case 3:
+            case 24:
+                this.writeUint24(value);
+                break;
+            case 4:
+            case 32:
+                this.writeUint32(value);
+                break;
+            case 64:
+                this.writeUint64(value);
+                break;
+            default:
+                throw new Error(`Unexpected uint size: ${bytesOrBits}`);
+        }
+    }
+    readFloat(n = 32) {
+        switch(n){
+            case 4:
+            case 32:
+                return this.readFloat32();
+            case 8:
+            case 64:
+                return this.readFloat64();
+            default:
+                throw new Error(`Unexpected float size: ${n}`);
+        }
+    }
+    writeFloat(value, n = 32) {
+        switch(n){
+            case 4:
+            case 32:
+                this.writeFloat32(value);
+                break;
+            case 8:
+            case 64:
+                this.writeFloat64(value);
+                break;
+            default:
+                throw new Error(`Unexpected float size: ${n}`);
+        }
     }
     readDouble() {
         return this.readFloat64();
     }
+    writeDouble(value) {
+        this.writeFloat64(value);
+    }
     remaining() {
         return this.length - this.position;
     }
+    hasRemaining() {
+        return this.remaining() > 0;
+    }
+    readRemaining() {
+        return this.readBytes(this.remaining());
+    }
     toUint8Array() {
         return new Uint8Array(this.buffer);
     }
@@ -284,6 +466,11 @@ function asBuffer(o) {
     toBase64() {
         return ArrayBuffers.toBase64(this.buffer);
     }
+    willWrite(length) {
+        if (this.remaining() < length) {
+            this.resize(this.position + length);
+        }
+    }
 }
 function safeNumber(n) {
     if (n > Number.MAX_SAFE_INTEGER) {
@@ -291,5 +478,17 @@ function safeNumber(n) {
     }
     return Number(n);
 }
+function bigintOf(n) {
+    if (typeof n === 'bigint') {
+        return n;
+    }
+    return BigInt(n);
+}
+function requireNumber(n) {
+    if (typeof n !== 'number') {
+        throw new Error(`Expected number, got ${n}`);
+    }
+    return n;
+}
 
 //# sourceMappingURL=ByteBuffer.js.map