@wener/utils 1.1.42 → 1.1.44

package/lib/strings/renderTemplate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/strings/renderTemplate.ts"],"sourcesContent":["import { get } from '../objects/get';\n\n/**\n * render template like js template string\n *\n * @example\n * renderTemplate('My name is ${name}',{name:'wener'})\n * // 'My name is wener'\n *\n * @param match `js` for `${name}`, common for `{{name}}`\n */\nexport function renderTemplate(\n  template: string,\n  data: ((v: string) => any) | object | undefined,\n  match: 'js' | 'common' | RegExp = 'js',\n) {\n  let getter: Function;\n  if (!data) {\n    // todo warning in dev\n    getter = () => '';\n  } else if (typeof data === 'function') {\n    getter = data;\n  } else {\n    getter = (v: string) => get(data, v);\n  }\n  if (typeof match === 'string') {\n    match = Matches[match] || Matches.js;\n  }\n  return template.replace(match, (_, g) => {\n    return getter(g.trim());\n  });\n}\n\nconst Matches: Record<string, RegExp> = {\n  js: /\\${(.*?)}/g,\n  common: /{{(.*?)}}/g,\n};\n"],"names":["get","renderTemplate","template","data","match","getter","v","Matches","js","replace","_","g","trim","common"],"mappings":"AAAA,SAASA,GAAG,QAAQ,iBAAiB;AAErC;;;;;;;;CAQC,GACD,OAAO,SAASC,eACdC,QAAgB,EAChBC,IAA+C,EAC/CC,QAAkC,IAAI;IAEtC,IAAIC;IACJ,IAAI,CAACF,MAAM;QACT,sBAAsB;QACtBE,SAAS,IAAM;IACjB,OAAO,IAAI,OAAOF,SAAS,YAAY;QACrCE,SAASF;IACX,OAAO;QACLE,SAAS,CAACC,IAAcN,IAAIG,MAAMG;IACpC;IACA,IAAI,OAAOF,UAAU,UAAU;QAC7BA,QAAQG,OAAO,CAACH,MAAM,IAAIG,QAAQC,EAAE;IACtC;IACA,OAAON,SAASO,OAAO,CAACL,OAAO,CAACM,GAAGC;QACjC,OAAON,OAAOM,EAAEC,IAAI;IACtB;AACF;AAEA,MAAML,UAAkC;IACtCC,IAAI;IACJK,QAAQ;AACV"}
+{"version":3,"sources":["../../src/strings/renderTemplate.ts"],"sourcesContent":["import { get } from '../objects/get';\n\n/**\n * render template like js template string\n *\n * @example\n * renderTemplate('My name is ${name}',{name:'wener'})\n * // 'My name is wener'\n *\n * @param match `js` for `${name}`, common for `{{name}}`\n */\nexport function renderTemplate(\n  template: string,\n  data: ((v: string) => any) | object | undefined,\n  match: 'js' | 'common' | RegExp = 'js',\n) {\n  let getter: Function;\n  if (!data) {\n    // todo warning in dev\n    getter = () => '';\n  } else if (typeof data === 'function') {\n    getter = data;\n  } else {\n    getter = (v: string) => get(data, v);\n  }\n  if (typeof match === 'string') {\n    match = Matches[match] || Matches.js;\n  }\n  return template.replace(match, (_, g) => {\n    return getter(g.trim());\n  });\n}\n\nconst Matches: Record<string, RegExp> = {\n  js: /\\${(.*?)}/g,\n  common: /{{(.*?)}}/g,\n};\n"],"names":["get","renderTemplate","template","data","match","getter","v","Matches","js","replace","_","g","trim","common"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,GAAG,QAAQ,iBAAiB;AAErC;;;;;;;;CAQC,GACD,OAAO,SAASC,eACdC,QAAgB,EAChBC,IAA+C,EAC/CC,QAAkC,IAAI;IAEtC,IAAIC;IACJ,IAAI,CAACF,MAAM;QACT,sBAAsB;QACtBE,SAAS,IAAM;IACjB,OAAO,IAAI,OAAOF,SAAS,YAAY;QACrCE,SAASF;IACX,OAAO;QACLE,SAAS,CAACC,IAAcN,IAAIG,MAAMG;IACpC;IACA,IAAI,OAAOF,UAAU,UAAU;QAC7BA,QAAQG,OAAO,CAACH,MAAM,IAAIG,QAAQC,EAAE;IACtC;IACA,OAAON,SAASO,OAAO,CAACL,OAAO,CAACM,GAAGC;QACjC,OAAON,OAAOM,EAAEC,IAAI;IACtB;AACF;AAEA,MAAML,UAAkC;IACtCC,IAAI;IACJK,QAAQ;AACV"}

package/lib/typedoc.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/typedoc.ts"],"sourcesContent":["export * from './index';\n// fixme md5 conflict\n// export * from './server';\n"],"names":[],"mappings":"AAAA,cAAc,UAAU,CACxB,qBAAqB;CACrB,4BAA4B"}
+{"version":3,"sources":["../src/typedoc.ts"],"sourcesContent":["export * from './index';\n// fixme md5 conflict\n// export * from './server';\n"],"names":[],"rangeMappings":";","mappings":"AAAA,cAAc,UAAU,CACxB,qBAAqB;CACrB,4BAA4B"}

package/lib/types.d.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.d.ts"],"sourcesContent":["declare var __DEV__: boolean;\n\nnamespace NodeJS {\n  interface Process {\n    // webpack check\n    readonly browser?: boolean;\n  }\n  interface ProcessEnv {\n    readonly NODE_ENV: 'development' | 'production' | 'test';\n  }\n}\n\nexport type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;\nexport type Constructor<T = {}> = new (...args: any[]) => T;\nexport type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\nexport type PartialRequired<T, K extends keyof T> = Partial<Omit<T, K>> & Required<Pick<T, K>>;\n\n/*\nhttps://github.com/total-typescript/ts-reset/blob/main/src/entrypoints/filter-boolean.d.ts\nhttps://github.com/sindresorhus/type-fest\n */\n"],"names":[],"mappings":"AAeA,WAA+F,CAE/F;;;CAGC"}
+{"version":3,"sources":["../src/types.d.ts"],"sourcesContent":["declare var __DEV__: boolean;\n\nnamespace NodeJS {\n  interface Process {\n    // webpack check\n    readonly browser?: boolean;\n  }\n  interface ProcessEnv {\n    readonly NODE_ENV: 'development' | 'production' | 'test';\n  }\n}\n\nexport type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;\nexport type Constructor<T = {}> = new (...args: any[]) => T;\nexport type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\nexport type PartialRequired<T, K extends keyof T> = Partial<Omit<T, K>> & Required<Pick<T, K>>;\n\n/*\nhttps://github.com/total-typescript/ts-reset/blob/main/src/entrypoints/filter-boolean.d.ts\nhttps://github.com/sindresorhus/type-fest\n */\n"],"names":[],"rangeMappings":";;;","mappings":"AAeA,WAA+F,CAE/F;;;CAGC"}

package/lib/validations/asserts.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/validations/asserts.ts"],"sourcesContent":["export function assert(condition: any, msg?: string): asserts condition {\n  // if (!condition) {\n  //   throw new AssertionError(msg);\n  // }\n  console.assert(!condition, msg);\n}\n\nexport function assertIsDefined<T>(val: T): asserts val is NonNullable<T> {\n  // if (val === undefined || val === null) {\n  //   throw new AssertionError(`Expected 'val' to be defined, but received ${val}`);\n  // }\n  console.assert(val === undefined || val === null, 'Expected defined');\n}\n"],"names":["assert","condition","msg","console","assertIsDefined","val","undefined"],"mappings":"AAAA,OAAO,SAASA,OAAOC,SAAc,EAAEC,GAAY;IACjD,oBAAoB;IACpB,mCAAmC;IACnC,IAAI;IACJC,QAAQH,MAAM,CAAC,CAACC,WAAWC;AAC7B;AAEA,OAAO,SAASE,gBAAmBC,GAAM;IACvC,2CAA2C;IAC3C,mFAAmF;IACnF,IAAI;IACJF,QAAQH,MAAM,CAACK,QAAQC,aAAaD,QAAQ,MAAM;AACpD"}
+{"version":3,"sources":["../../src/validations/asserts.ts"],"sourcesContent":["export function assert(condition: any, msg?: string): asserts condition {\n  // if (!condition) {\n  //   throw new AssertionError(msg);\n  // }\n  console.assert(!condition, msg);\n}\n\nexport function assertIsDefined<T>(val: T): asserts val is NonNullable<T> {\n  // if (val === undefined || val === null) {\n  //   throw new AssertionError(`Expected 'val' to be defined, but received ${val}`);\n  // }\n  console.assert(val === undefined || val === null, 'Expected defined');\n}\n"],"names":["assert","condition","msg","console","assertIsDefined","val","undefined"],"rangeMappings":";;;;;;;;;;;","mappings":"AAAA,OAAO,SAASA,OAAOC,SAAc,EAAEC,GAAY;IACjD,oBAAoB;IACpB,mCAAmC;IACnC,IAAI;IACJC,QAAQH,MAAM,CAAC,CAACC,WAAWC;AAC7B;AAEA,OAAO,SAASE,gBAAmBC,GAAM;IACvC,2CAA2C;IAC3C,mFAAmF;IACnF,IAAI;IACJF,QAAQH,MAAM,CAACK,QAAQC,aAAaD,QAAQ,MAAM;AACpD"}

package/lib/validations/isUUID.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/validations/isUUID.ts"],"sourcesContent":["export function isUUID(str: string | undefined | null) {\n  return Boolean(str) && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(String(str));\n}\n"],"names":["isUUID","str","Boolean","test","String"],"mappings":"AAAA,OAAO,SAASA,OAAOC,GAA8B;IACnD,OAAOC,QAAQD,QAAQ,yEAAyEE,IAAI,CAACC,OAAOH;AAC9G"}
+{"version":3,"sources":["../../src/validations/isUUID.ts"],"sourcesContent":["export function isUUID(str: string | undefined | null) {\n  return Boolean(str) && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(String(str));\n}\n"],"names":["isUUID","str","Boolean","test","String"],"rangeMappings":";;","mappings":"AAAA,OAAO,SAASA,OAAOC,GAA8B;IACnD,OAAOC,QAAQD,QAAQ,yEAAyEE,IAAI,CAACC,OAAOH;AAC9G"}

package/lib/validations/parseTimestamp.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/validations/parseTimestamp.ts"],"sourcesContent":["export function parseTimestamp(raw?: string | number | Date): Date | undefined {\n  if (!raw) {\n    return undefined;\n  }\n  if (raw instanceof Date) {\n    return raw;\n  }\n\n  if (typeof raw === 'string' && /^[0-9.]+$/.test(raw)) {\n    let n = parseFloat(raw);\n    const len = Math.floor(n).toString().length;\n    /*\n    最常见的是 10 位和 13 位\n    9999999999 - 10*9 - 1970-04-26\n    99999999999 - 11*9 - 1973\n    999999999999 - 12*9 - 2001\n     */\n    if (len <= 11) {\n      n *= 1000;\n    }\n    return new Date(n);\n  } else if (typeof raw === 'string') {\n    const date = new Date(raw);\n    if (!isNaN(+date)) {\n      return date;\n    }\n  }\n  throw new Error(`parseTimestamp: invalid \"${raw}\"`);\n}\n"],"names":["parseTimestamp","raw","undefined","Date","test","n","parseFloat","len","Math","floor","toString","length","date","isNaN","Error"],"mappings":"AAAA,OAAO,SAASA,eAAeC,GAA4B;IACzD,IAAI,CAACA,KAAK;QACR,OAAOC;IACT;IACA,IAAID,eAAeE,MAAM;QACvB,OAAOF;IACT;IAEA,IAAI,OAAOA,QAAQ,YAAY,YAAYG,IAAI,CAACH,MAAM;QACpD,IAAII,IAAIC,WAAWL;QACnB,MAAMM,MAAMC,KAAKC,KAAK,CAACJ,GAAGK,QAAQ,GAAGC,MAAM;QAC3C;;;;;KAKC,GACD,IAAIJ,OAAO,IAAI;YACbF,KAAK;QACP;QACA,OAAO,IAAIF,KAAKE;IAClB,OAAO,IAAI,OAAOJ,QAAQ,UAAU;QAClC,MAAMW,OAAO,IAAIT,KAAKF;QACtB,IAAI,CAACY,MAAM,CAACD,OAAO;YACjB,OAAOA;QACT;IACF;IACA,MAAM,IAAIE,MAAM,CAAC,yBAAyB,EAAEb,IAAI,CAAC,CAAC;AACpD"}
+{"version":3,"sources":["../../src/validations/parseTimestamp.ts"],"sourcesContent":["export function parseTimestamp(raw?: string | number | Date): Date | undefined {\n  if (!raw) {\n    return undefined;\n  }\n  if (raw instanceof Date) {\n    return raw;\n  }\n\n  if (typeof raw === 'string' && /^[0-9.]+$/.test(raw)) {\n    let n = parseFloat(raw);\n    const len = Math.floor(n).toString().length;\n    /*\n    最常见的是 10 位和 13 位\n    9999999999 - 10*9 - 1970-04-26\n    99999999999 - 11*9 - 1973\n    999999999999 - 12*9 - 2001\n     */\n    if (len <= 11) {\n      n *= 1000;\n    }\n    return new Date(n);\n  } else if (typeof raw === 'string') {\n    const date = new Date(raw);\n    if (!isNaN(+date)) {\n      return date;\n    }\n  }\n  throw new Error(`parseTimestamp: invalid \"${raw}\"`);\n}\n"],"names":["parseTimestamp","raw","undefined","Date","test","n","parseFloat","len","Math","floor","toString","length","date","isNaN","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAO,SAASA,eAAeC,GAA4B;IACzD,IAAI,CAACA,KAAK;QACR,OAAOC;IACT;IACA,IAAID,eAAeE,MAAM;QACvB,OAAOF;IACT;IAEA,IAAI,OAAOA,QAAQ,YAAY,YAAYG,IAAI,CAACH,MAAM;QACpD,IAAII,IAAIC,WAAWL;QACnB,MAAMM,MAAMC,KAAKC,KAAK,CAACJ,GAAGK,QAAQ,GAAGC,MAAM;QAC3C;;;;;KAKC,GACD,IAAIJ,OAAO,IAAI;YACbF,KAAK;QACP;QACA,OAAO,IAAIF,KAAKE;IAClB,OAAO,IAAI,OAAOJ,QAAQ,UAAU;QAClC,MAAMW,OAAO,IAAIT,KAAKF;QACtB,IAAI,CAACY,MAAM,CAACD,OAAO;YACjB,OAAOA;QACT;IACF;IACA,MAAM,IAAIE,MAAM,CAAC,yBAAyB,EAAEb,IAAI,CAAC,CAAC;AACpD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.42",
+  "version": "1.1.44",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {
@@ -78,15 +78,15 @@
     }
   },
   "devDependencies": {
-    "@sinclair/typebox": "^0.32.15",
+    "@sinclair/typebox": "^0.32.24",
     "@types/lodash": "^4.17.0",
     "@types/ws": "^8.5.10",
-    "@wener/utils": "link:.",
+    "@wener/utils": "link:",
     "https-proxy-agent": "^7.0.4",
     "lodash": "^4.17.21",
     "node-fetch": "^3.3.2",
-    "undici": "^6.9.0",
-    "zod": "^3.22.4"
+    "undici": "^6.14.1",
+    "zod": "^3.23.4"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/index.ts

@@ -74,6 +74,7 @@ export { createTranslate } from './i18n/createTranslate';
 export { isBuffer } from './io/isBuffer';
 export { isTransferable } from './io/isTransferable';
 export { ArrayBuffers } from './io/ArrayBuffers';
+export { ByteArray } from './io/ByteArray';
 export { Buffer } from './io/Buffer';
 export { parseDataUri, type ParsedDataUri } from './io/parseDataUri';
 export type { AbstractEncoding } from './io/AbstractEncoding';

package/src/io/ArrayBuffers.ts

@@ -71,6 +71,8 @@ export interface ArrayBuffers {
   toHex(v: BufferSource): string;
 
   resize(v: ArrayBuffer, newByteLength: number): ArrayBuffer;
+
+  // truncate(v: ArrayBufferLike, len?: number): ArrayBufferLike;
 }
 
 type ToStringEncoding =
@@ -155,8 +157,12 @@ export class ArrayBuffers {
     return this.toUint8Array(ArrayBuffers.from(v, 'hex'));
   };
 
-  static resize = (v: ArrayBuffer, newByteLength: number): ArrayBuffer => {
-    if ('resize' in v) {
+  static resize = (v: ArrayBufferLike, newByteLength?: number) => {
+    if (newByteLength === undefined || newByteLength === null) {
+      return v;
+    }
+
+    if ('resize' in v && (v as any).resizable) {
       (v as any).resize(newByteLength);
       return v;
     }
@@ -339,6 +345,23 @@ export class ArrayBuffers {
     }
   };
 
+  // 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) => {
     // https://stackoverflow.com/questions/10786128/appending-arraybuffers
 
@@ -390,7 +413,13 @@ const hexLookupTable = (function () {
 
 declare global {
   interface ArrayBuffer {
-    // resize(newByteLength: number): void;
+    resize?: (newByteLength: number) => void;
+    resizable?: boolean;
+  }
+
+  interface SharedArrayBuffer {
+    resize?: (newByteLength: number) => void;
+    resizable?: boolean;
   }
 
   interface Uint8Array {

package/src/io/ByteArray.ts

@@ -0,0 +1,403 @@
+import { isDefined } from '../langs/isDefined';
+import { ArrayBuffers } from './ArrayBuffers';
+
+type AnyBuffer = BufferSource | ArrayBufferLike;
+
+function asBuffer(o: AnyBuffer) {
+  if (o instanceof ArrayBuffer) {
+    return o;
+  }
+  if (ArrayBuffer.isView(o)) {
+    // 保留 offset&length
+    if (o.byteLength !== o.buffer.byteLength) {
+      // ArrayBuffer 没有 subarray
+      // if ('subarray' in o.buffer) {
+      //   return (o.buffer as any).subarray(o.byteOffset, o.byteOffset + o.byteLength);
+      // }
+      return o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength);
+    }
+    return o.buffer;
+  }
+  return o;
+}
+
+// function asView(o: AnyBuffer) {
+//   if (o instanceof DataView) {
+//     return o;
+//   }
+//   if (ArrayBuffer.isView(o)) {
+//     // 不 clone 也能保留 offset&length
+//     return new DataView(o.buffer, o.byteOffset, o.byteLength);
+//   }
+//   return new DataView(o);
+// }
+
+/**
+ * @see https://www.egret.uk/docs/egretengine/engine/egret.ByteArray
+ * @see https://netty.io/4.1/api/io/netty/buffer/ByteBuf.html
+ */
+export class ByteArray {
+  position = 0;
+
+  #buffer: ArrayBufferLike;
+  #view: DataView;
+
+  constructor(buffer: AnyBuffer = new ArrayBuffer(0, { maxByteLength: 1024 })) {
+    this.#buffer = asBuffer(buffer);
+    // note prefer view over buffer, avoid the slice overhead ?
+    this.#view = new DataView(this.#buffer);
+  }
+
+  get view() {
+    return this.#view;
+  }
+
+  get buffer(): ArrayBufferLike {
+    return this.#buffer;
+  }
+
+  set buffer(buffer: AnyBuffer) {
+    this.#buffer = asBuffer(buffer);
+    this.#view = new DataView(this.#buffer);
+  }
+
+  get length() {
+    return this.view.byteLength;
+  }
+
+  set length(length: number) {
+    this.resize(length);
+  }
+
+  private ensureSpace(length: number) {
+    if (this.remaining() < length) {
+      this.resize(this.length + length);
+    }
+  }
+
+  resize(newLength: number) {
+    // Chrome 111, Nodejs 20
+    let buf = this.buffer;
+    if (buf.resize && (!isDefined(buf.resizable) || buf.resizable)) {
+      buf.resize(newLength);
+    } else {
+      let newBuffer = new ArrayBuffer(newLength);
+      new Uint8Array(newBuffer).set(new Uint8Array(buf));
+      this.buffer = newBuffer;
+    }
+  }
+
+  writeByte(value: number) {
+    this.ensureSpace(1);
+    this.view.setUint8(this.position++, value);
+  }
+
+  writeBytes(bytes: ArrayBufferLike) {
+    this.ensureSpace(bytes.byteLength);
+    new Uint8Array(this.buffer).set(new Uint8Array(bytes), this.position);
+    this.position += bytes.byteLength;
+  }
+
+  writeInt8(value: number) {
+    this.ensureSpace(1);
+    this.view.setInt8(this.position, value);
+    this.position += 1;
+  }
+
+  writeUint8(value: number) {
+    this.ensureSpace(1);
+    this.view.setUint8(this.position, value);
+    this.position += 1;
+  }
+
+  writeInt16(value: number) {
+    this.ensureSpace(2);
+    this.view.setInt16(this.position, value);
+    this.position += 2;
+  }
+
+  writeUint16(value: number) {
+    this.ensureSpace(2);
+    this.view.setUint16(this.position, value);
+    this.position += 2;
+  }
+
+  writeInt32(value: number) {
+    this.ensureSpace(4);
+    this.view.setInt32(this.position, value);
+    this.position += 4;
+  }
+
+  writeUint32(value: number) {
+    this.ensureSpace(4);
+    this.view.setUint32(this.position, value);
+    this.position += 4;
+  }
+
+  writeInt64(value: bigint) {
+    this.ensureSpace(8);
+    this.view.setBigInt64(this.position, value);
+    this.position += 8;
+  }
+
+  writeUint64(value: bigint) {
+    this.ensureSpace(8);
+    this.view.setBigUint64(this.position, value);
+    this.position += 8;
+  }
+
+  writeFloat32(value: number) {
+    this.ensureSpace(4);
+    this.view.setFloat32(this.position, value);
+    this.position += 4;
+  }
+
+  writeFloat64(value: number) {
+    this.ensureSpace(8);
+    this.view.setFloat64(this.position, value);
+    this.position += 8;
+  }
+
+  writeBoolean(value: boolean) {
+    this.writeByte(value ? 1 : 0);
+  }
+
+  writeString(value: string): void;
+  writeString(value: string, len?: number): void;
+  writeString(value: string, len?: number) {
+    let encoder = new TextEncoder();
+    let bytes = encoder.encode(value);
+    this.writeBytes(ArrayBuffers.resize(bytes.buffer, len));
+  }
+
+  readByte() {
+    return this.view.getUint8(this.position++);
+  }
+
+  readBytes(length: number) {
+    let bytes = this.buffer.slice(this.position, this.position + length);
+    this.position += length;
+    return bytes;
+  }
+
+  readInt8() {
+    let value = this.view.getInt8(this.position);
+    this.position += 1;
+    return value;
+  }
+
+  readUint8() {
+    let value = this.view.getUint8(this.position);
+    this.position += 1;
+    return value;
+  }
+
+  readInt16() {
+    let value = this.view.getInt16(this.position);
+    this.position += 2;
+    return value;
+  }
+
+  readUint16() {
+    let value = this.view.getUint16(this.position);
+    this.position += 2;
+    return value;
+  }
+
+  readInt32() {
+    let value = this.view.getInt32(this.position);
+    this.position += 4;
+    return value;
+  }
+
+  readUint32() {
+    let value = this.view.getUint32(this.position);
+    this.position += 4;
+    return value;
+  }
+
+  readInt64() {
+    let value = this.view.getBigInt64(this.position);
+    this.position += 8;
+    return safeNumber(value);
+  }
+
+  readUint64() {
+    let value = this.view.getBigUint64(this.position);
+    this.position += 8;
+    return safeNumber(value);
+  }
+
+  readFloat32() {
+    let value = this.view.getFloat32(this.position);
+    this.position += 4;
+    return value;
+  }
+
+  readFloat64() {
+    let value = this.view.getFloat64(this.position);
+    this.position += 8;
+    return value;
+  }
+
+  readBoolean() {
+    return this.readByte() === 1;
+  }
+
+  readString(length: number) {
+    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);
+  }
+
+  readHexString(length: number) {
+    let bytes = this.readBytes(length);
+    return ArrayBuffers.toHex(bytes);
+  }
+
+  writeInt24(value: number) {
+    this.writeUint8(value & 0xff);
+    this.writeUint16(value >> 8);
+  }
+
+  readInt24() {
+    return this.readUint8() | (this.readUint16() << 8);
+  }
+
+  writeZero(length: number) {
+    this.writeBytes(new Uint8Array(length).buffer);
+  }
+
+  writeValue(typ: TypedValue['type'], val: TypedValue['value']): void;
+  writeValue(tv: TypedValue): void;
+  writeValue(a: any, b?: any) {
+    const tv: TypedValue = typeof a === 'string' ? { type: a, value: b } : a;
+    const { type, value, length } = tv;
+    switch (type) {
+      case 'uint8':
+        this.writeUint8(value);
+        break;
+      case 'byte':
+      case 'int8':
+        this.writeInt8(value);
+        break;
+      case 'uint16':
+        this.writeUint16(value);
+        break;
+      case 'int16':
+        this.writeInt16(value);
+        break;
+      case 'uint32':
+        this.writeUint32(value);
+        break;
+      case 'int32':
+        this.writeInt32(value);
+        break;
+      case 'float32':
+        this.writeFloat32(value);
+        break;
+      case 'float64':
+        this.writeFloat64(value);
+        break;
+      case 'string':
+        this.writeString(value, length);
+        break;
+      case 'boolean':
+        this.writeBoolean(value);
+        break;
+      case 'bytes':
+        this.writeBytes(value);
+        break;
+      default:
+        throw new Error(`Unknown type ${type}`);
+    }
+  }
+
+  readInt() {
+    return this.readInt32();
+  }
+
+  readFloat() {
+    return this.readFloat32();
+  }
+
+  readDouble() {
+    return this.readFloat64();
+  }
+
+  remaining() {
+    return this.view.byteLength - this.position;
+  }
+
+  toUint8Array() {
+    return new Uint8Array(this.buffer);
+  }
+
+  toHex() {
+    return ArrayBuffers.toHex(this.buffer);
+  }
+}
+
+export interface TypedValue {
+  type:
+    | 'byte'
+    | 'bytes'
+    | 'uint8'
+    | 'int8'
+    | 'uint16'
+    | 'int16'
+    | 'uint32'
+    | 'int32'
+    | 'float32'
+    | 'float64'
+    | 'string'
+    | 'boolean';
+  value: any;
+  length?: number;
+}
+
+export function toDump(data: BufferSource) {
+  return Array.from(ArrayBuffers.toHex(data).match(/.{1,32}/g) ?? [])
+    .map((v, i) => {
+      let idxPrefix = `${i.toString(16).padStart(8, '0')}:`;
+      let content = Array.from(v.match(/.{4}/g) ?? []).join(' ');
+      let chars = Array.from(new Uint8Array(ArrayBuffers.fromHex(v).buffer)).map((v) => {
+        let c = String.fromCharCode(v);
+        if (v < 32 || v > 126) {
+          c = '.';
+        }
+        return c;
+      });
+      return [idxPrefix, content.padEnd(40, ' '), chars.join('')].join(' ');
+    })
+    .join('\n');
+}
+
+/**
+ * Chrome Websocket Binary format
+ * ```
+ * 00000000: 0000 0000 0000 0000 0000 0000 0000 0000  ................
+ * ```
+ */
+export function fromDump(dump: string) {
+  return ArrayBuffers.fromHex(
+    dump
+      .split('\n')
+      .map((v) => {
+        return v.substring(10, 10 + 41).replaceAll(' ', '');
+      })
+      .join(''),
+  );
+}
+
+function safeNumber(n: bigint) {
+  if (n > Number.MAX_SAFE_INTEGER) {
+    return n;
+  }
+  return Number(n);
+}