zeed 1.3.0 → 1.4.0

package/dist/common/bin/lib0/binary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"binary.mjs","names":[],"sources":["../../../../src/common/bin/lib0/binary.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Binary data constants.\n */\n\n/**\n * n-th bit activated.\n */\nexport const BIT1 = 0b00000000000000000000000000000001\nexport const BIT2 = 0b00000000000000000000000000000010\nexport const BIT3 = 0b00000000000000000000000000000100\nexport const BIT4 = 0b00000000000000000000000000001000\nexport const BIT5 = 0b00000000000000000000000000010000\nexport const BIT6 = 0b00000000000000000000000000100000\nexport const BIT7 = 0b00000000000000000000000001000000\nexport const BIT8 = 0b00000000000000000000000010000000\nexport const BIT9 = 0b00000000000000000000000100000000\nexport const BIT10 = 0b00000000000000000000001000000000\nexport const BIT11 = 0b00000000000000000000010000000000\nexport const BIT12 = 0b00000000000000000000100000000000\nexport const BIT13 = 0b00000000000000000001000000000000\nexport const BIT14 = 0b00000000000000000010000000000000\nexport const BIT15 = 0b00000000000000000100000000000000\nexport const BIT16 = 0b00000000000000001000000000000000\nexport const BIT17 = 0b00000000000000010000000000000000\nexport const BIT18 = 0b00000000000000100000000000000000\nexport const BIT19 = 0b00000000000001000000000000000000\nexport const BIT20 = 0b00000000000010000000000000000000\nexport const BIT21 = 0b00000000000100000000000000000000\nexport const BIT22 = 0b00000000001000000000000000000000\nexport const BIT23 = 0b00000000010000000000000000000000\nexport const BIT24 = 0b00000000100000000000000000000000\nexport const BIT25 = 0b00000001000000000000000000000000\nexport const BIT26 = 0b00000010000000000000000000000000\nexport const BIT27 = 0b00000100000000000000000000000000\nexport const BIT28 = 0b00001000000000000000000000000000\nexport const BIT29 = 0b00010000000000000000000000000000\nexport const BIT30 = 0b00100000000000000000000000000000\nexport const BIT31 = 0b01000000000000000000000000000000\nexport const BIT32 = 0b10000000000000000000000000000000\n\n// for (let i = 0; i < 32; i++) {\n//   let s = `export const BIT${i}= 0b`\n//   for (let j = 0; j < 32; j++)\n//     s += (31 - j) === i ? '1' : '0'\n//   console.log(s)\n// }\n\n/**\n * First n bits activated.\n */\n\nexport const BITS0 = 0b00000000000000000000000000000000\nexport const BITS1 = 0b00000000000000000000000000000001\nexport const BITS2 = 0b00000000000000000000000000000011\nexport const BITS3 = 0b00000000000000000000000000000111\nexport const BITS4 = 0b00000000000000000000000000001111\nexport const BITS5 = 0b00000000000000000000000000011111\nexport const BITS6 = 0b00000000000000000000000000111111\nexport const BITS7 = 0b00000000000000000000000001111111\nexport const BITS8 = 0b00000000000000000000000011111111\nexport const BITS9 = 0b00000000000000000000000111111111\nexport const BITS10 = 0b00000000000000000000001111111111\nexport const BITS11 = 0b00000000000000000000011111111111\nexport const BITS12 = 0b00000000000000000000111111111111\nexport const BITS13 = 0b00000000000000000001111111111111\nexport const BITS14 = 0b00000000000000000011111111111111\nexport const BITS15 = 0b00000000000000000111111111111111\nexport const BITS16 = 0b00000000000000001111111111111111\nexport const BITS17 = 0b00000000000000011111111111111111\nexport const BITS18 = 0b00000000000000111111111111111111\nexport const BITS19 = 0b00000000000001111111111111111111\nexport const BITS20 = 0b00000000000011111111111111111111\nexport const BITS21 = 0b00000000000111111111111111111111\nexport const BITS22 = 0b00000000001111111111111111111111\nexport const BITS23 = 0b00000000011111111111111111111111\nexport const BITS24 = 0b00000000111111111111111111111111\nexport const BITS25 = 0b00000001111111111111111111111111\nexport const BITS26 = 0b00000011111111111111111111111111\nexport const BITS27 = 0b00000111111111111111111111111111\nexport const BITS28 = 0b00001111111111111111111111111111\nexport const BITS29 = 0b00011111111111111111111111111111\nexport const BITS30 = 0b00111111111111111111111111111111\nexport const BITS31 = 0b01111111111111111111111111111111\nexport const BITS32 = 0b11111111111111111111111111111111\n\n// for (let i = 0; i < 32; i++) {\n//   let s = `export const BITS${i}= 0b`\n//   for (let j = 0; j < 32; j++)\n//     s += (32 - j) > i ? '0' : '1'\n//   console.log(s)\n// }\n\n/*\nvar BIT0 = 1;\nvar BIT1 = 2;\nvar BIT2 = 4;\nvar BIT3 = 8;\nvar BIT4 = 16;\nvar BIT5 = 32;\nvar BIT6 = 64;\nvar BIT7 = 128;\nvar BIT8 = 256;\nvar BIT9 = 512;\nvar BIT10 = 1024;\nvar BIT11 = 2048;\nvar BIT12 = 4096;\nvar BIT13 = 8192;\nvar BIT14 = 16384;\nvar BIT15 = 32768;\nvar BIT16 = 65536;\nvar BIT17 = 131072;\nvar BIT18 = 262144;\nvar BIT19 = 524288;\nvar BIT20 = 1048576;\nvar BIT21 = 2097152;\nvar BIT22 = 4194304;\nvar BIT23 = 8388608;\nvar BIT24 = 16777216;\nvar BIT25 = 33554432;\nvar BIT26 = 67108864;\nvar BIT27 = 134217728;\nvar BIT28 = 268435456;\nvar BIT29 = 536870912;\nvar BIT30 = 1073741824;\nvar BIT31 = 2147483648;\nvar BITS0 = 0;\nvar BITS1 = 1;\nvar BITS2 = 3;\nvar BITS3 = 7;\nvar BITS4 = 15;\nvar BITS5 = 31;\nvar BITS6 = 63;\nvar BITS7 = 127;\nvar BITS8 = 255;\nvar BITS9 = 511;\nvar BITS10 = 1023;\nvar BITS11 = 2047;\nvar BITS12 = 4095;\nvar BITS13 = 8191;\nvar BITS14 = 16383;\nvar BITS15 = 32767;\nvar BITS16 = 65535;\nvar BITS17 = 131071;\nvar BITS18 = 262143;\nvar BITS19 = 524287;\nvar BITS20 = 1048575;\nvar BITS21 = 2097151;\nvar BITS22 = 4194303;\nvar BITS23 = 8388607;\nvar BITS24 = 16777215;\nvar BITS25 = 33554431;\nvar BITS26 = 67108863;\nvar BITS27 = 134217727;\nvar BITS28 = 268435455;\nvar BITS29 = 536870911;\nvar BITS30 = 1073741823;\nvar BITS31 = 2147483647;\nvar BITS32 = 4294967295;\n\n*/\n"],"mappings":"AASA,MAAa,EAAO,EACP,EAAO,EACP,EAAO,EACP,EAAO,EACP,EAAO,GACP,EAAO,GACP,EAAO,GACP,EAAO,IACP,EAAO,IACP,EAAQ,IACR,EAAQ,KACR,EAAQ,KACR,EAAQ,KACR,EAAQ,KACR,EAAQ,MACR,EAAQ,MACR,EAAQ,MACR,EAAQ,OACR,EAAQ,OACR,EAAQ,OACR,EAAQ,QACR,EAAQ,QACR,EAAQ,QACR,EAAQ,QACR,EAAQ,SACR,EAAQ,SACR,EAAQ,SACR,EAAQ,UACR,EAAQ,UACR,EAAQ,UACR,EAAQ,WACR,EAAQ,WAaR,EAAQ,EACR,EAAQ,EACR,EAAQ,EACR,EAAQ,EACR,EAAQ,GACR,EAAQ,GACR,EAAQ,GACR,EAAQ,IACR,EAAQ,IACR,EAAQ,IACR,EAAS,KACT,EAAS,KACT,EAAS,KACT,EAAS,KACT,EAAS,MACT,EAAS,MACT,EAAS,MACT,EAAS,OACT,EAAS,OACT,EAAS,OACT,EAAS,QACT,EAAS,QACT,GAAS,QACT,GAAS,QACT,GAAS,SACT,GAAS,SACT,GAAS,SACT,GAAS,UACT,GAAS,UACT,GAAS,UACT,GAAS,WACT,GAAS,WACT,GAAS"}
+{"version":3,"file":"binary.mjs","names":[],"sources":["../../../../src/common/bin/lib0/binary.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Binary data constants.\n */\n\n/**\n * n-th bit activated.\n */\nexport const BIT1 = 0b00000000000000000000000000000001\nexport const BIT2 = 0b00000000000000000000000000000010\nexport const BIT3 = 0b00000000000000000000000000000100\nexport const BIT4 = 0b00000000000000000000000000001000\nexport const BIT5 = 0b00000000000000000000000000010000\nexport const BIT6 = 0b00000000000000000000000000100000\nexport const BIT7 = 0b00000000000000000000000001000000\nexport const BIT8 = 0b00000000000000000000000010000000\nexport const BIT9 = 0b00000000000000000000000100000000\nexport const BIT10 = 0b00000000000000000000001000000000\nexport const BIT11 = 0b00000000000000000000010000000000\nexport const BIT12 = 0b00000000000000000000100000000000\nexport const BIT13 = 0b00000000000000000001000000000000\nexport const BIT14 = 0b00000000000000000010000000000000\nexport const BIT15 = 0b00000000000000000100000000000000\nexport const BIT16 = 0b00000000000000001000000000000000\nexport const BIT17 = 0b00000000000000010000000000000000\nexport const BIT18 = 0b00000000000000100000000000000000\nexport const BIT19 = 0b00000000000001000000000000000000\nexport const BIT20 = 0b00000000000010000000000000000000\nexport const BIT21 = 0b00000000000100000000000000000000\nexport const BIT22 = 0b00000000001000000000000000000000\nexport const BIT23 = 0b00000000010000000000000000000000\nexport const BIT24 = 0b00000000100000000000000000000000\nexport const BIT25 = 0b00000001000000000000000000000000\nexport const BIT26 = 0b00000010000000000000000000000000\nexport const BIT27 = 0b00000100000000000000000000000000\nexport const BIT28 = 0b00001000000000000000000000000000\nexport const BIT29 = 0b00010000000000000000000000000000\nexport const BIT30 = 0b00100000000000000000000000000000\nexport const BIT31 = 0b01000000000000000000000000000000\nexport const BIT32 = 0b10000000000000000000000000000000\n\n// for (let i = 0; i < 32; i++) {\n//   let s = `export const BIT${i}= 0b`\n//   for (let j = 0; j < 32; j++)\n//     s += (31 - j) === i ? '1' : '0'\n//   console.log(s)\n// }\n\n/**\n * First n bits activated.\n */\n\nexport const BITS0 = 0b00000000000000000000000000000000\nexport const BITS1 = 0b00000000000000000000000000000001\nexport const BITS2 = 0b00000000000000000000000000000011\nexport const BITS3 = 0b00000000000000000000000000000111\nexport const BITS4 = 0b00000000000000000000000000001111\nexport const BITS5 = 0b00000000000000000000000000011111\nexport const BITS6 = 0b00000000000000000000000000111111\nexport const BITS7 = 0b00000000000000000000000001111111\nexport const BITS8 = 0b00000000000000000000000011111111\nexport const BITS9 = 0b00000000000000000000000111111111\nexport const BITS10 = 0b00000000000000000000001111111111\nexport const BITS11 = 0b00000000000000000000011111111111\nexport const BITS12 = 0b00000000000000000000111111111111\nexport const BITS13 = 0b00000000000000000001111111111111\nexport const BITS14 = 0b00000000000000000011111111111111\nexport const BITS15 = 0b00000000000000000111111111111111\nexport const BITS16 = 0b00000000000000001111111111111111\nexport const BITS17 = 0b00000000000000011111111111111111\nexport const BITS18 = 0b00000000000000111111111111111111\nexport const BITS19 = 0b00000000000001111111111111111111\nexport const BITS20 = 0b00000000000011111111111111111111\nexport const BITS21 = 0b00000000000111111111111111111111\nexport const BITS22 = 0b00000000001111111111111111111111\nexport const BITS23 = 0b00000000011111111111111111111111\nexport const BITS24 = 0b00000000111111111111111111111111\nexport const BITS25 = 0b00000001111111111111111111111111\nexport const BITS26 = 0b00000011111111111111111111111111\nexport const BITS27 = 0b00000111111111111111111111111111\nexport const BITS28 = 0b00001111111111111111111111111111\nexport const BITS29 = 0b00011111111111111111111111111111\nexport const BITS30 = 0b00111111111111111111111111111111\nexport const BITS31 = 0b01111111111111111111111111111111\nexport const BITS32 = 0b11111111111111111111111111111111\n\n// for (let i = 0; i < 32; i++) {\n//   let s = `export const BITS${i}= 0b`\n//   for (let j = 0; j < 32; j++)\n//     s += (32 - j) > i ? '0' : '1'\n//   console.log(s)\n// }\n\n/*\nvar BIT0 = 1;\nvar BIT1 = 2;\nvar BIT2 = 4;\nvar BIT3 = 8;\nvar BIT4 = 16;\nvar BIT5 = 32;\nvar BIT6 = 64;\nvar BIT7 = 128;\nvar BIT8 = 256;\nvar BIT9 = 512;\nvar BIT10 = 1024;\nvar BIT11 = 2048;\nvar BIT12 = 4096;\nvar BIT13 = 8192;\nvar BIT14 = 16384;\nvar BIT15 = 32768;\nvar BIT16 = 65536;\nvar BIT17 = 131072;\nvar BIT18 = 262144;\nvar BIT19 = 524288;\nvar BIT20 = 1048576;\nvar BIT21 = 2097152;\nvar BIT22 = 4194304;\nvar BIT23 = 8388608;\nvar BIT24 = 16777216;\nvar BIT25 = 33554432;\nvar BIT26 = 67108864;\nvar BIT27 = 134217728;\nvar BIT28 = 268435456;\nvar BIT29 = 536870912;\nvar BIT30 = 1073741824;\nvar BIT31 = 2147483648;\nvar BITS0 = 0;\nvar BITS1 = 1;\nvar BITS2 = 3;\nvar BITS3 = 7;\nvar BITS4 = 15;\nvar BITS5 = 31;\nvar BITS6 = 63;\nvar BITS7 = 127;\nvar BITS8 = 255;\nvar BITS9 = 511;\nvar BITS10 = 1023;\nvar BITS11 = 2047;\nvar BITS12 = 4095;\nvar BITS13 = 8191;\nvar BITS14 = 16383;\nvar BITS15 = 32767;\nvar BITS16 = 65535;\nvar BITS17 = 131071;\nvar BITS18 = 262143;\nvar BITS19 = 524287;\nvar BITS20 = 1048575;\nvar BITS21 = 2097151;\nvar BITS22 = 4194303;\nvar BITS23 = 8388607;\nvar BITS24 = 16777215;\nvar BITS25 = 33554431;\nvar BITS26 = 67108863;\nvar BITS27 = 134217727;\nvar BITS28 = 268435455;\nvar BITS29 = 536870911;\nvar BITS30 = 1073741823;\nvar BITS31 = 2147483647;\nvar BITS32 = 4294967295;\n\n*/\n"],"mappings":";;;;;;;;;AASA,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;;;;AAarB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,SAAS"}

package/dist/common/bin/lib0/buffer.cjs

@@ -1,2 +1,43 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./decoding.cjs`),t=require(`./encoding.cjs`);function n(e){return new Uint8Array(e)}function r(e){let t=n(e.byteLength);return t.set(e),t}function i(e){let n=t.createBinEncoder();return t.writeAny(n,e),t.encodeToUint8Array(n)}function a(t){return e.readAny(e.createDecoder(t))}exports.copyUint8Array=r,exports.createUint8ArrayFromLen=n,exports.decodeAny=a,exports.encodeAny=i;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_bin_lib0_decoding = require('./decoding.cjs');
+const require_common_bin_lib0_encoding = require('./encoding.cjs');
+
+//#region src/common/bin/lib0/buffer.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* Utility functions to work with buffers (Uint8Array).
+*/
+function createUint8ArrayFromLen(len) {
+	return new Uint8Array(len);
+}
+/**
+* Copy the content of an Uint8Array view to a new ArrayBuffer.
+*/
+function copyUint8Array(uint8Array) {
+	const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
+	newBuf.set(uint8Array);
+	return newBuf;
+}
+/**
+* Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.
+* See encoding.writeAny for more information.
+*/
+function encodeAny(data) {
+	const encoder = require_common_bin_lib0_encoding.createBinEncoder();
+	require_common_bin_lib0_encoding.writeAny(encoder, data);
+	return require_common_bin_lib0_encoding.encodeToUint8Array(encoder);
+}
+/**
+* Decode an any-encoded value.
+*/
+function decodeAny(buf) {
+	return require_common_bin_lib0_decoding.readAny(require_common_bin_lib0_decoding.createDecoder(buf));
+}
+
+//#endregion
+exports.copyUint8Array = copyUint8Array;
+exports.createUint8ArrayFromLen = createUint8ArrayFromLen;
+exports.decodeAny = decodeAny;
+exports.encodeAny = encodeAny;
 //# sourceMappingURL=buffer.cjs.map

package/dist/common/bin/lib0/buffer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.cjs","names":["createBinEncoder","encodeToUint8Array","readAny","createDecoder"],"sources":["../../../../src/common/bin/lib0/buffer.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\nimport { createDecoder, readAny } from './decoding'\nimport { createBinEncoder, encodeToUint8Array, writeAny } from './encoding'\n\nexport function createUint8ArrayFromLen(len: number): Uint8Array {\n  return new Uint8Array(len)\n}\n\n/**\n * Copy the content of an Uint8Array view to a new ArrayBuffer.\n */\nexport function copyUint8Array(uint8Array: Uint8Array): Uint8Array {\n  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength)\n  newBuf.set(uint8Array)\n  return newBuf\n}\n\n/**\n * Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.\n * See encoding.writeAny for more information.\n */\nexport function encodeAny(data: any): Uint8Array {\n  const encoder = createBinEncoder()\n  writeAny(encoder, data)\n  return encodeToUint8Array(encoder)\n}\n\n/**\n * Decode an any-encoded value.\n */\nexport function decodeAny(buf: Uint8Array): any {\n  return readAny(createDecoder(buf))\n}\n"],"mappings":"iIASA,SAAgB,EAAwB,EAAyB,CAC/D,OAAO,IAAI,WAAW,EAAI,CAM5B,SAAgB,EAAe,EAAoC,CACjE,IAAM,EAAS,EAAwB,EAAW,WAAW,CAE7D,OADA,EAAO,IAAI,EAAW,CACf,EAOT,SAAgB,EAAU,EAAuB,CAC/C,IAAM,EAAUA,EAAAA,kBAAkB,CAElC,OADA,EAAA,SAAS,EAAS,EAAK,CAChBC,EAAAA,mBAAmB,EAAQ,CAMpC,SAAgB,EAAU,EAAsB,CAC9C,OAAOC,EAAAA,QAAQC,EAAAA,cAAc,EAAI,CAAC"}
+{"version":3,"file":"buffer.cjs","names":["createBinEncoder","encodeToUint8Array","readAny","createDecoder"],"sources":["../../../../src/common/bin/lib0/buffer.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\nimport { createDecoder, readAny } from './decoding'\nimport { createBinEncoder, encodeToUint8Array, writeAny } from './encoding'\n\nexport function createUint8ArrayFromLen(len: number): Uint8Array {\n  return new Uint8Array(len)\n}\n\n/**\n * Copy the content of an Uint8Array view to a new ArrayBuffer.\n */\nexport function copyUint8Array(uint8Array: Uint8Array): Uint8Array {\n  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength)\n  newBuf.set(uint8Array)\n  return newBuf\n}\n\n/**\n * Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.\n * See encoding.writeAny for more information.\n */\nexport function encodeAny(data: any): Uint8Array {\n  const encoder = createBinEncoder()\n  writeAny(encoder, data)\n  return encodeToUint8Array(encoder)\n}\n\n/**\n * Decode an any-encoded value.\n */\nexport function decodeAny(buf: Uint8Array): any {\n  return readAny(createDecoder(buf))\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,wBAAwB,KAAyB;AAC/D,QAAO,IAAI,WAAW,IAAI;;;;;AAM5B,SAAgB,eAAe,YAAoC;CACjE,MAAM,SAAS,wBAAwB,WAAW,WAAW;AAC7D,QAAO,IAAI,WAAW;AACtB,QAAO;;;;;;AAOT,SAAgB,UAAU,MAAuB;CAC/C,MAAM,UAAUA,mDAAkB;AAClC,2CAAS,SAAS,KAAK;AACvB,QAAOC,oDAAmB,QAAQ;;;;;AAMpC,SAAgB,UAAU,KAAsB;AAC9C,QAAOC,yCAAQC,+CAAc,IAAI,CAAC"}

package/dist/common/bin/lib0/buffer.mjs

@@ -1,2 +1,39 @@
-import{createDecoder as e,readAny as t}from"./decoding.mjs";import{createBinEncoder as n,encodeToUint8Array as r,writeAny as i}from"./encoding.mjs";function a(e){return new Uint8Array(e)}function o(e){let t=a(e.byteLength);return t.set(e),t}function s(e){let t=n();return i(t,e),r(t)}function c(n){return t(e(n))}export{o as copyUint8Array,a as createUint8ArrayFromLen,c as decodeAny,s as encodeAny};
+import { createDecoder, readAny } from "./decoding.mjs";
+import { createBinEncoder, encodeToUint8Array, writeAny } from "./encoding.mjs";
+
+//#region src/common/bin/lib0/buffer.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* Utility functions to work with buffers (Uint8Array).
+*/
+function createUint8ArrayFromLen(len) {
+	return new Uint8Array(len);
+}
+/**
+* Copy the content of an Uint8Array view to a new ArrayBuffer.
+*/
+function copyUint8Array(uint8Array) {
+	const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
+	newBuf.set(uint8Array);
+	return newBuf;
+}
+/**
+* Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.
+* See encoding.writeAny for more information.
+*/
+function encodeAny(data) {
+	const encoder = createBinEncoder();
+	writeAny(encoder, data);
+	return encodeToUint8Array(encoder);
+}
+/**
+* Decode an any-encoded value.
+*/
+function decodeAny(buf) {
+	return readAny(createDecoder(buf));
+}
+
+//#endregion
+export { copyUint8Array, createUint8ArrayFromLen, decodeAny, encodeAny };
 //# sourceMappingURL=buffer.mjs.map

package/dist/common/bin/lib0/buffer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.mjs","names":[],"sources":["../../../../src/common/bin/lib0/buffer.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\nimport { createDecoder, readAny } from './decoding'\nimport { createBinEncoder, encodeToUint8Array, writeAny } from './encoding'\n\nexport function createUint8ArrayFromLen(len: number): Uint8Array {\n  return new Uint8Array(len)\n}\n\n/**\n * Copy the content of an Uint8Array view to a new ArrayBuffer.\n */\nexport function copyUint8Array(uint8Array: Uint8Array): Uint8Array {\n  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength)\n  newBuf.set(uint8Array)\n  return newBuf\n}\n\n/**\n * Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.\n * See encoding.writeAny for more information.\n */\nexport function encodeAny(data: any): Uint8Array {\n  const encoder = createBinEncoder()\n  writeAny(encoder, data)\n  return encodeToUint8Array(encoder)\n}\n\n/**\n * Decode an any-encoded value.\n */\nexport function decodeAny(buf: Uint8Array): any {\n  return readAny(createDecoder(buf))\n}\n"],"mappings":"oJASA,SAAgB,EAAwB,EAAyB,CAC/D,OAAO,IAAI,WAAW,EAAI,CAM5B,SAAgB,EAAe,EAAoC,CACjE,IAAM,EAAS,EAAwB,EAAW,WAAW,CAE7D,OADA,EAAO,IAAI,EAAW,CACf,EAOT,SAAgB,EAAU,EAAuB,CAC/C,IAAM,EAAU,GAAkB,CAElC,OADA,EAAS,EAAS,EAAK,CAChB,EAAmB,EAAQ,CAMpC,SAAgB,EAAU,EAAsB,CAC9C,OAAO,EAAQ,EAAc,EAAI,CAAC"}
+{"version":3,"file":"buffer.mjs","names":[],"sources":["../../../../src/common/bin/lib0/buffer.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\nimport { createDecoder, readAny } from './decoding'\nimport { createBinEncoder, encodeToUint8Array, writeAny } from './encoding'\n\nexport function createUint8ArrayFromLen(len: number): Uint8Array {\n  return new Uint8Array(len)\n}\n\n/**\n * Copy the content of an Uint8Array view to a new ArrayBuffer.\n */\nexport function copyUint8Array(uint8Array: Uint8Array): Uint8Array {\n  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength)\n  newBuf.set(uint8Array)\n  return newBuf\n}\n\n/**\n * Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.\n * See encoding.writeAny for more information.\n */\nexport function encodeAny(data: any): Uint8Array {\n  const encoder = createBinEncoder()\n  writeAny(encoder, data)\n  return encodeToUint8Array(encoder)\n}\n\n/**\n * Decode an any-encoded value.\n */\nexport function decodeAny(buf: Uint8Array): any {\n  return readAny(createDecoder(buf))\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,wBAAwB,KAAyB;AAC/D,QAAO,IAAI,WAAW,IAAI;;;;;AAM5B,SAAgB,eAAe,YAAoC;CACjE,MAAM,SAAS,wBAAwB,WAAW,WAAW;AAC7D,QAAO,IAAI,WAAW;AACtB,QAAO;;;;;;AAOT,SAAgB,UAAU,MAAuB;CAC/C,MAAM,UAAU,kBAAkB;AAClC,UAAS,SAAS,KAAK;AACvB,QAAO,mBAAmB,QAAQ;;;;;AAMpC,SAAgB,UAAU,KAAsB;AAC9C,QAAO,QAAQ,cAAc,IAAI,CAAC"}

package/dist/common/bin/lib0/create.cjs

@@ -1,2 +1,25 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,t,n){return new Uint8Array(e,t,n)}function t(e){return new Uint8Array(e)}exports.createUint8ArrayFromArrayBuffer=t,exports.createUint8ArrayViewFromArrayBuffer=e;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/common/bin/lib0/create.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* Utility functions to work with buffers (Uint8Array).
+*/
+/**
+* Create Uint8Array with initial content from buffer
+*/
+function createUint8ArrayViewFromArrayBuffer(buffer, byteOffset, length) {
+	return new Uint8Array(buffer, byteOffset, length);
+}
+/**
+* Create Uint8Array with initial content from buffer
+*/
+function createUint8ArrayFromArrayBuffer(buffer) {
+	return new Uint8Array(buffer);
+}
+
+//#endregion
+exports.createUint8ArrayFromArrayBuffer = createUint8ArrayFromArrayBuffer;
+exports.createUint8ArrayViewFromArrayBuffer = createUint8ArrayViewFromArrayBuffer;
 //# sourceMappingURL=create.cjs.map

package/dist/common/bin/lib0/create.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create.cjs","names":[],"sources":["../../../../src/common/bin/lib0/create.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayViewFromArrayBuffer(buffer: ArrayBufferLike, byteOffset: number, length: number) {\n  return new Uint8Array(buffer, byteOffset, length)\n}\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayFromArrayBuffer(buffer: ArrayBuffer) {\n  return new Uint8Array(buffer)\n}\n"],"mappings":"mEASA,SAAgB,EAAoC,EAAyB,EAAoB,EAAgB,CAC/G,OAAO,IAAI,WAAW,EAAQ,EAAY,EAAO,CAMnD,SAAgB,EAAgC,EAAqB,CACnE,OAAO,IAAI,WAAW,EAAO"}
+{"version":3,"file":"create.cjs","names":[],"sources":["../../../../src/common/bin/lib0/create.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayViewFromArrayBuffer(buffer: ArrayBufferLike, byteOffset: number, length: number) {\n  return new Uint8Array(buffer, byteOffset, length)\n}\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayFromArrayBuffer(buffer: ArrayBuffer) {\n  return new Uint8Array(buffer)\n}\n"],"mappings":";;;;;;;;;;;AASA,SAAgB,oCAAoC,QAAyB,YAAoB,QAAgB;AAC/G,QAAO,IAAI,WAAW,QAAQ,YAAY,OAAO;;;;;AAMnD,SAAgB,gCAAgC,QAAqB;AACnE,QAAO,IAAI,WAAW,OAAO"}

package/dist/common/bin/lib0/create.mjs

@@ -1,2 +1,22 @@
-function e(e,t,n){return new Uint8Array(e,t,n)}function t(e){return new Uint8Array(e)}export{t as createUint8ArrayFromArrayBuffer,e as createUint8ArrayViewFromArrayBuffer};
+//#region src/common/bin/lib0/create.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* Utility functions to work with buffers (Uint8Array).
+*/
+/**
+* Create Uint8Array with initial content from buffer
+*/
+function createUint8ArrayViewFromArrayBuffer(buffer, byteOffset, length) {
+	return new Uint8Array(buffer, byteOffset, length);
+}
+/**
+* Create Uint8Array with initial content from buffer
+*/
+function createUint8ArrayFromArrayBuffer(buffer) {
+	return new Uint8Array(buffer);
+}
+
+//#endregion
+export { createUint8ArrayFromArrayBuffer, createUint8ArrayViewFromArrayBuffer };
 //# sourceMappingURL=create.mjs.map

package/dist/common/bin/lib0/create.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create.mjs","names":[],"sources":["../../../../src/common/bin/lib0/create.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayViewFromArrayBuffer(buffer: ArrayBufferLike, byteOffset: number, length: number) {\n  return new Uint8Array(buffer, byteOffset, length)\n}\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayFromArrayBuffer(buffer: ArrayBuffer) {\n  return new Uint8Array(buffer)\n}\n"],"mappings":"AASA,SAAgB,EAAoC,EAAyB,EAAoB,EAAgB,CAC/G,OAAO,IAAI,WAAW,EAAQ,EAAY,EAAO,CAMnD,SAAgB,EAAgC,EAAqB,CACnE,OAAO,IAAI,WAAW,EAAO"}
+{"version":3,"file":"create.mjs","names":[],"sources":["../../../../src/common/bin/lib0/create.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility functions to work with buffers (Uint8Array).\n */\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayViewFromArrayBuffer(buffer: ArrayBufferLike, byteOffset: number, length: number) {\n  return new Uint8Array(buffer, byteOffset, length)\n}\n\n/**\n * Create Uint8Array with initial content from buffer\n */\nexport function createUint8ArrayFromArrayBuffer(buffer: ArrayBuffer) {\n  return new Uint8Array(buffer)\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,oCAAoC,QAAyB,YAAoB,QAAgB;AAC/G,QAAO,IAAI,WAAW,QAAQ,YAAY,OAAO;;;;;AAMnD,SAAgB,gCAAgC,QAAqB;AACnE,QAAO,IAAI,WAAW,OAAO"}

package/dist/common/bin/lib0/decoding.cjs

@@ -1,2 +1,326 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`./binary.cjs`);const e=require(`./create.cjs`),t=require(`./string.cjs`),n=`Unexpected end of array`,r=`Integer out of Range`;var i=class{arr;pos;constructor(e){this.arr=e,this.pos=0}};function a(e){return new i(e)}function o(e){return e.pos!==e.arr.length}function s(e,t=e.pos){let n=a(e.arr);return n.pos=t,n}function c(t,n){let r=e.createUint8ArrayViewFromArrayBuffer(t.arr.buffer,t.pos+t.arr.byteOffset,n);return t.pos+=n,r}function l(e){let t=0,i=1,a=e.arr.length;for(;e.pos<a;){let n=e.arr[e.pos++];if(t+=(n&127)*i,i*=128,n<128)return t;if(t>2**53-1)throw Error(r)}throw Error(n)}function u(e){return c(e,l(e))}function d(e){return c(e,e.arr.length-e.pos)}function f(e){return e.pos++}function p(e){return e.arr[e.pos++]}function m(e){let t=e.arr[e.pos]+(e.arr[e.pos+1]<<8);return e.pos+=2,t}function h(e){let t=e.arr[e.pos]+(e.arr[e.pos+1]<<8)+(e.arr[e.pos+2]<<16)+(e.arr[e.pos+3]<<24)>>>0;return e.pos+=4,t}function g(e){let t=e.arr[e.pos+3]+(e.arr[e.pos+2]<<8)+(e.arr[e.pos+1]<<16)+(e.arr[e.pos]<<24)>>>0;return e.pos+=4,t}function _(e){return e.arr[e.pos]}function v(e){return e.arr[e.pos]+(e.arr[e.pos+1]<<8)}function y(e){return e.arr[e.pos]+(e.arr[e.pos+1]<<8)+(e.arr[e.pos+2]<<16)+(e.arr[e.pos+3]<<24)>>>0}function b(e){let t=e.arr[e.pos++],i=t&63,a=64,o=(t&64)>0?-1:1;if(!(t&128))return o*i;let s=e.arr.length;for(;e.pos<s;){if(t=e.arr[e.pos++],i+=(t&127)*a,a*=128,t<128)return o*i;if(i>2**53-1)throw Error(r)}throw Error(n)}function x(e){let t=e.pos,n=l(e);return e.pos=t,n}function S(e){let t=e.pos,n=b(e);return e.pos=t,n}function C(e){let t=l(e);if(t===0)return``;{let n=String.fromCodePoint(p(e));if(--t<100)for(;t--;)n+=String.fromCodePoint(p(e));else for(;t>0;){let r=t<1e4?t:1e4,i=e.arr.subarray(e.pos,e.pos+r);e.pos+=r,n+=String.fromCodePoint(...i),t-=r}return decodeURIComponent(escape(n))}}function w(e){let n=t.getUtf8TextDecoder();return n?n.decode(u(e)):C(e)}function T(e){let t=e.pos,n=w(e);return e.pos=t,n}function E(e,t){let n=new DataView(e.arr.buffer,e.arr.byteOffset+e.pos,t);return e.pos+=t,n}function D(e){return E(e,4).getFloat32(0,!1)}function O(e){return E(e,8).getFloat64(0,!1)}function k(e){return E(e,8).getBigInt64(0,!1)}function A(e){return E(e,8).getBigUint64(0,!1)}const j=[e=>void 0,e=>null,b,D,O,k,e=>!1,e=>!0,w,e=>{let t=l(e),n={};for(let r=0;r<t;r++){let t=w(e);n[t]=M(e)}return n},e=>{let t=l(e),n=[];for(let r=0;r<t;r++)n.push(M(e));return n},u];function M(e){return j[127-p(e)](e)}exports.BinDecoder=i,exports.clone=s,exports.createDecoder=a,exports.hasContent=o,exports.peekUint16=v,exports.peekUint32=y,exports.peekUint8=_,exports.peekVarInt=S,exports.peekVarString=T,exports.peekVarUint=x,exports.readAny=M,exports.readBigInt64=k,exports.readBigUint64=A,exports.readFloat32=D,exports.readFloat64=O,exports.readFromDataView=E,exports.readTailAsUint8Array=d,exports.readUint16=m,exports.readUint32=h,exports.readUint32BigEndian=g,exports.readUint8=p,exports.readUint8Array=c,exports.readVarInt=b,exports.readVarString=w,exports.readVarUint=l,exports.readVarUint8Array=u,exports.skip8=f;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_bin_lib0_binary = require('./binary.cjs');
+const require_common_bin_lib0_create = require('./create.cjs');
+const require_common_bin_lib0_string = require('./string.cjs');
+
+//#region src/common/bin/lib0/decoding.ts
+/**
+* Original at https://github.com/dmonad/lib0
+*
+* Efficient schema-less binary decoding with support for variable length encoding.
+*
+* Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+*
+* Encodes numbers in little-endian order (least to most significant byte order)
+* and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+* which is also used in Protocol Buffers.
+*
+* ```js
+* // encoding step
+* const encoder = new encoding.createEncoder()
+* encoding.writeVarUint(encoder, 256)
+* encoding.writeVarString(encoder, 'Hello world!')
+* const buf = encoding.toUint8Array(encoder)
+* ```
+*
+* ```js
+* // decoding step
+* const decoder = new decoding.createDecoder(buf)
+* decoding.readVarUint(decoder) // => 256
+* decoding.readVarString(decoder) // => 'Hello world!'
+* decoding.hasContent(decoder) // => false - all data is read
+* ```
+*/
+const errorUnexpectedEndOfArray = "Unexpected end of array";
+const errorIntegerOutOfRange = "Integer out of Range";
+/**
+* A BinDecoder handles the decoding of an Uint8Array.
+*/
+var BinDecoder = class {
+	/** Decoding target. */
+	arr;
+	/** Current decoding position. */
+	pos;
+	constructor(uint8Array) {
+		this.arr = uint8Array;
+		this.pos = 0;
+	}
+};
+function createDecoder(uint8Array) {
+	return new BinDecoder(uint8Array);
+}
+function hasContent(decoder) {
+	return decoder.pos !== decoder.arr.length;
+}
+/**
+* Clone a decoder instance.
+* Optionally set a new position parameter.
+*/
+function clone(decoder, newPos = decoder.pos) {
+	const _decoder = createDecoder(decoder.arr);
+	_decoder.pos = newPos;
+	return _decoder;
+}
+/**
+* Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+*
+* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+*/
+function readUint8Array(decoder, len) {
+	const view = require_common_bin_lib0_create.createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+	decoder.pos += len;
+	return view;
+}
+/**
+* Read unsigned integer (32bit) with variable length.
+* 1/8th of the storage is used as encoding overhead.
+* numbers < 2^7 is stored in one bytlength
+* numbers < 2^14 is stored in two bylength
+*/
+function readVarUint(decoder) {
+	let num = 0;
+	let mult = 1;
+	const len = decoder.arr.length;
+	while (decoder.pos < len) {
+		const r = decoder.arr[decoder.pos++];
+		num = num + (r & 127) * mult;
+		mult *= 128;
+		if (r < 128) return num;
+		if (num > Number.MAX_SAFE_INTEGER) throw new Error(errorIntegerOutOfRange);
+	}
+	throw new Error(errorUnexpectedEndOfArray);
+}
+/**
+* Read variable length Uint8Array.
+*
+* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+*/
+function readVarUint8Array(decoder) {
+	return readUint8Array(decoder, readVarUint(decoder));
+}
+/**
+* Read the rest of the content as an ArrayBuffer
+*/
+function readTailAsUint8Array(decoder) {
+	return readUint8Array(decoder, decoder.arr.length - decoder.pos);
+}
+/**
+* Skip one byte, jump to the next position.
+*/
+function skip8(decoder) {
+	return decoder.pos++;
+}
+/**
+* Read one byte as unsigned integer.
+*/
+function readUint8(decoder) {
+	return decoder.arr[decoder.pos++];
+}
+/**
+* Read 2 bytes as unsigned integer.
+*/
+function readUint16(decoder) {
+	const uint = decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8);
+	decoder.pos += 2;
+	return uint;
+}
+/**
+* Read 4 bytes as unsigned integer.
+*/
+function readUint32(decoder) {
+	const uint = decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8) + (decoder.arr[decoder.pos + 2] << 16) + (decoder.arr[decoder.pos + 3] << 24) >>> 0;
+	decoder.pos += 4;
+	return uint;
+}
+/**
+* Read 4 bytes as unsigned integer in big endian order.
+* (most significant byte first)
+*/
+function readUint32BigEndian(decoder) {
+	const uint = decoder.arr[decoder.pos + 3] + (decoder.arr[decoder.pos + 2] << 8) + (decoder.arr[decoder.pos + 1] << 16) + (decoder.arr[decoder.pos] << 24) >>> 0;
+	decoder.pos += 4;
+	return uint;
+}
+/**
+* Look ahead without incrementing the position
+* to the next byte and read it as unsigned integer.
+*/
+function peekUint8(decoder) {
+	return decoder.arr[decoder.pos];
+}
+/**
+* Look ahead without incrementing the position
+* to the next byte and read it as unsigned integer.
+*/
+function peekUint16(decoder) {
+	return decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8);
+}
+/**
+* Look ahead without incrementing the position
+* to the next byte and read it as unsigned integer.
+*/
+function peekUint32(decoder) {
+	return decoder.arr[decoder.pos] + (decoder.arr[decoder.pos + 1] << 8) + (decoder.arr[decoder.pos + 2] << 16) + (decoder.arr[decoder.pos + 3] << 24) >>> 0;
+}
+/**
+* Read signed integer (32bit) with variable length.
+* 1/8th of the storage is used as encoding overhead.
+* numbers < 2^7 is stored in one bytlength
+* numbers < 2^14 is stored in two bylength
+* @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
+*/
+function readVarInt(decoder) {
+	let r = decoder.arr[decoder.pos++];
+	let num = r & 63;
+	let mult = 64;
+	const sign = (r & 64) > 0 ? -1 : 1;
+	if ((r & 128) === 0) return sign * num;
+	const len = decoder.arr.length;
+	while (decoder.pos < len) {
+		r = decoder.arr[decoder.pos++];
+		num = num + (r & 127) * mult;
+		mult *= 128;
+		if (r < 128) return sign * num;
+		if (num > Number.MAX_SAFE_INTEGER) throw new Error(errorIntegerOutOfRange);
+	}
+	throw new Error(errorUnexpectedEndOfArray);
+}
+/**
+* Look ahead and read varUint without incrementing position
+*/
+function peekVarUint(decoder) {
+	const pos = decoder.pos;
+	const s = readVarUint(decoder);
+	decoder.pos = pos;
+	return s;
+}
+/**
+* Look ahead and read varUint without incrementing position
+*/
+function peekVarInt(decoder) {
+	const pos = decoder.pos;
+	const s = readVarInt(decoder);
+	decoder.pos = pos;
+	return s;
+}
+/**
+* We don't test this function anymore as we use native decoding/encoding by default now.
+* Better not modify this anymore..
+*
+* Transforming utf8 to a string is pretty expensive. The code performs 10x better
+* when String.fromCodePoint is fed with all characters as arguments.
+* But most environments have a maximum number of arguments per functions.
+* For effiency reasons we apply a maximum of 10000 characters at once.
+*/
+function _readVarStringPolyfill(decoder) {
+	let remainingLen = readVarUint(decoder);
+	if (remainingLen === 0) return "";
+	else {
+		let encodedString = String.fromCodePoint(readUint8(decoder));
+		if (--remainingLen < 100) while (remainingLen--) encodedString += String.fromCodePoint(readUint8(decoder));
+		else while (remainingLen > 0) {
+			const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+			const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
+			decoder.pos += nextLen;
+			encodedString += String.fromCodePoint(...bytes);
+			remainingLen -= nextLen;
+		}
+		return decodeURIComponent(escape(encodedString));
+	}
+}
+/**
+* Read string of variable length
+* varUint is used to store the length of the string
+*/
+function readVarString(decoder) {
+	const utf8TextDecoder = require_common_bin_lib0_string.getUtf8TextDecoder();
+	return utf8TextDecoder ? utf8TextDecoder.decode(readVarUint8Array(decoder)) : _readVarStringPolyfill(decoder);
+}
+/**
+* Look ahead and read varString without incrementing position
+*/
+function peekVarString(decoder) {
+	const pos = decoder.pos;
+	const s = readVarString(decoder);
+	decoder.pos = pos;
+	return s;
+}
+function readFromDataView(decoder, len) {
+	const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
+	decoder.pos += len;
+	return dv;
+}
+function readFloat32(decoder) {
+	return readFromDataView(decoder, 4).getFloat32(0, false);
+}
+function readFloat64(decoder) {
+	return readFromDataView(decoder, 8).getFloat64(0, false);
+}
+function readBigInt64(decoder) {
+	return readFromDataView(decoder, 8).getBigInt64(0, false);
+}
+function readBigUint64(decoder) {
+	return readFromDataView(decoder, 8).getBigUint64(0, false);
+}
+const readAnyLookupTable = [
+	(_) => void 0,
+	(_) => null,
+	readVarInt,
+	readFloat32,
+	readFloat64,
+	readBigInt64,
+	(_) => false,
+	(_) => true,
+	readVarString,
+	(decoder) => {
+		const len = readVarUint(decoder);
+		const obj = {};
+		for (let i = 0; i < len; i++) {
+			const key = readVarString(decoder);
+			obj[key] = readAny(decoder);
+		}
+		return obj;
+	},
+	(decoder) => {
+		const len = readVarUint(decoder);
+		const arr = [];
+		for (let i = 0; i < len; i++) arr.push(readAny(decoder));
+		return arr;
+	},
+	readVarUint8Array
+];
+function readAny(decoder) {
+	return readAnyLookupTable[127 - readUint8(decoder)](decoder);
+}
+
+//#endregion
+exports.BinDecoder = BinDecoder;
+exports.clone = clone;
+exports.createDecoder = createDecoder;
+exports.hasContent = hasContent;
+exports.peekUint16 = peekUint16;
+exports.peekUint32 = peekUint32;
+exports.peekUint8 = peekUint8;
+exports.peekVarInt = peekVarInt;
+exports.peekVarString = peekVarString;
+exports.peekVarUint = peekVarUint;
+exports.readAny = readAny;
+exports.readBigInt64 = readBigInt64;
+exports.readBigUint64 = readBigUint64;
+exports.readFloat32 = readFloat32;
+exports.readFloat64 = readFloat64;
+exports.readFromDataView = readFromDataView;
+exports.readTailAsUint8Array = readTailAsUint8Array;
+exports.readUint16 = readUint16;
+exports.readUint32 = readUint32;
+exports.readUint32BigEndian = readUint32BigEndian;
+exports.readUint8 = readUint8;
+exports.readUint8Array = readUint8Array;
+exports.readVarInt = readVarInt;
+exports.readVarString = readVarString;
+exports.readVarUint = readVarUint;
+exports.readVarUint8Array = readVarUint8Array;
+exports.skip8 = skip8;
 //# sourceMappingURL=decoding.cjs.map

package/dist/common/bin/lib0/decoding.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"decoding.cjs","names":["createUint8ArrayViewFromArrayBuffer","getUtf8TextDecoder"],"sources":["../../../../src/common/bin/lib0/decoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary decoding with support for variable length encoding.\n *\n * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = new encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = new decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n */\n\nimport { BIT7, BIT8, BITS6, BITS7 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { getUtf8TextDecoder } from './string'\n\nconst errorUnexpectedEndOfArray = 'Unexpected end of array'\nconst errorIntegerOutOfRange = 'Integer out of Range'\n\n/**\n * A BinDecoder handles the decoding of an Uint8Array.\n */\nexport class BinDecoder {\n  /** Decoding target. */\n  arr: Uint8Array\n  /** Current decoding position. */\n  pos: number\n\n  constructor(uint8Array: Uint8Array) {\n    this.arr = uint8Array\n    this.pos = 0\n  }\n}\n\nexport function createDecoder(uint8Array: Uint8Array): BinDecoder {\n  return new BinDecoder(uint8Array)\n}\n\nexport function hasContent(decoder: BinDecoder): boolean {\n  return decoder.pos !== decoder.arr.length\n}\n\n/**\n * Clone a decoder instance.\n * Optionally set a new position parameter.\n */\nexport function clone(decoder: BinDecoder, newPos: number = decoder.pos): BinDecoder {\n  const _decoder = createDecoder(decoder.arr)\n  _decoder.pos = newPos\n  return _decoder\n}\n\n/**\n * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readUint8Array(decoder: BinDecoder, len: number): Uint8Array {\n  const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len)\n  decoder.pos += len\n  return view\n}\n\n/**\n * Read unsigned integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n */\nexport function readVarUint(decoder: BinDecoder): number {\n  let num = 0\n  let mult = 1\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    const r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult // shift $r << (7*#iterations) and add it to num\n    mult *= 128 // next iteration, shift 7 \"more\" to the left\n    if (r < BIT8)\n      return num\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Read variable length Uint8Array.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readVarUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, readVarUint(decoder))\n}\n\n/**\n * Read the rest of the content as an ArrayBuffer\n */\nexport function readTailAsUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, decoder.arr.length - decoder.pos)\n}\n\n/**\n * Skip one byte, jump to the next position.\n */\nexport function skip8(decoder: BinDecoder): number {\n  return decoder.pos++\n}\n\n/**\n * Read one byte as unsigned integer.\n */\nexport function readUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos++]\n}\n\n/**\n * Read 2 bytes as unsigned integer.\n */\nexport function readUint16(decoder: BinDecoder): number {\n  const uint = decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n  decoder.pos += 2\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer.\n */\nexport function readUint32(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function readUint32BigEndian(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos + 3]\n    + (decoder.arr[decoder.pos + 2] << 8)\n    + (decoder.arr[decoder.pos + 1] << 16)\n    + (decoder.arr[decoder.pos] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint16(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint32(decoder: BinDecoder): number {\n  return (\n    decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)\n  ) >>> 0\n}\n\n/**\n * Read signed integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.\n */\nexport function readVarInt(decoder: BinDecoder): number {\n  let r = decoder.arr[decoder.pos++]\n  let num = r & BITS6\n  let mult = 64\n  const sign = (r & BIT7) > 0 ? -1 : 1 // use Math.sign(?) for performance?\n  if ((r & BIT8) === 0) {\n    // don't continue reading\n    return sign * num\n  }\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult\n    mult *= 128\n    if (r < BIT8)\n      return sign * num\n\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarUint(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarUint(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarInt(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarInt(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * We don't test this function anymore as we use native decoding/encoding by default now.\n * Better not modify this anymore..\n *\n * Transforming utf8 to a string is pretty expensive. The code performs 10x better\n * when String.fromCodePoint is fed with all characters as arguments.\n * But most environments have a maximum number of arguments per functions.\n * For effiency reasons we apply a maximum of 10000 characters at once.\n */\nfunction _readVarStringPolyfill(decoder: BinDecoder): string {\n  let remainingLen = readVarUint(decoder)\n  if (remainingLen === 0) {\n    return ''\n  }\n  else {\n    let encodedString = String.fromCodePoint(readUint8(decoder)) // remember to decrease remainingLen\n    if (--remainingLen < 100) { // do not create a Uint8Array for small strings\n      while (remainingLen--)\n        encodedString += String.fromCodePoint(readUint8(decoder))\n    }\n    else {\n      while (remainingLen > 0) {\n        const nextLen = remainingLen < 10000 ? remainingLen : 10000\n        // this is dangerous, we create a fresh array view from the existing buffer\n        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen)\n        decoder.pos += nextLen\n        // Starting with ES5.1 we can supply a generic array-like object as arguments\n        encodedString += String.fromCodePoint(...bytes as any)\n        remainingLen -= nextLen\n      }\n    }\n    return decodeURIComponent(escape(encodedString))\n  }\n}\n\n/**\n * Read string of variable length\n * varUint is used to store the length of the string\n */\nexport function readVarString(decoder: BinDecoder): string {\n  const utf8TextDecoder = getUtf8TextDecoder()\n  return utf8TextDecoder\n    ? utf8TextDecoder.decode(readVarUint8Array(decoder))\n    : _readVarStringPolyfill(decoder)\n}\n\n/**\n * Look ahead and read varString without incrementing position\n */\nexport function peekVarString(decoder: BinDecoder): string {\n  const pos = decoder.pos\n  const s = readVarString(decoder)\n  decoder.pos = pos\n  return s\n}\n\nexport function readFromDataView(decoder: BinDecoder, len: number): DataView {\n  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len)\n  decoder.pos += len\n  return dv\n}\n\nexport function readFloat32(decoder: BinDecoder) {\n  return readFromDataView(decoder, 4).getFloat32(0, false)\n}\n\nexport function readFloat64(decoder: BinDecoder) {\n  return readFromDataView(decoder, 8).getFloat64(0, false)\n}\n\nexport function readBigInt64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigInt64(0, false)\n}\n\nexport function readBigUint64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigUint64(0, false)\n}\n\nconst readAnyLookupTable: Array<((arg0: BinDecoder) => any)> = [\n  _ => undefined, // CASE 127: undefined\n  _ => null, // CASE 126: null\n  readVarInt, // CASE 125: integer\n  readFloat32, // CASE 124: float32\n  readFloat64, // CASE 123: float64\n  readBigInt64, // CASE 122: bigint\n  _ => false, // CASE 121: boolean (false)\n  _ => true, // CASE 120: boolean (true)\n  readVarString, // CASE 119: string\n  (decoder) => { // CASE 118: object<string,any>\n    const len = readVarUint(decoder)\n    const obj: { [s: string]: any } = {}\n    for (let i = 0; i < len; i++) {\n      const key = readVarString(decoder)\n      obj[key] = readAny(decoder)\n    }\n    return obj\n  },\n  (decoder) => { // CASE 117: array<any>\n    const len = readVarUint(decoder)\n    const arr = []\n    for (let i = 0; i < len; i++)\n\n      arr.push(readAny(decoder))\n\n    return arr\n  },\n  readVarUint8Array, // CASE 116: Uint8Array\n]\n\nexport function readAny(decoder: BinDecoder) {\n  return readAnyLookupTable[127 - readUint8(decoder)](decoder)\n}\n"],"mappings":"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"}
+{"version":3,"file":"decoding.cjs","names":["createUint8ArrayViewFromArrayBuffer","getUtf8TextDecoder"],"sources":["../../../../src/common/bin/lib0/decoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary decoding with support for variable length encoding.\n *\n * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = new encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = new decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n */\n\nimport { BIT7, BIT8, BITS6, BITS7 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { getUtf8TextDecoder } from './string'\n\nconst errorUnexpectedEndOfArray = 'Unexpected end of array'\nconst errorIntegerOutOfRange = 'Integer out of Range'\n\n/**\n * A BinDecoder handles the decoding of an Uint8Array.\n */\nexport class BinDecoder {\n  /** Decoding target. */\n  arr: Uint8Array\n  /** Current decoding position. */\n  pos: number\n\n  constructor(uint8Array: Uint8Array) {\n    this.arr = uint8Array\n    this.pos = 0\n  }\n}\n\nexport function createDecoder(uint8Array: Uint8Array): BinDecoder {\n  return new BinDecoder(uint8Array)\n}\n\nexport function hasContent(decoder: BinDecoder): boolean {\n  return decoder.pos !== decoder.arr.length\n}\n\n/**\n * Clone a decoder instance.\n * Optionally set a new position parameter.\n */\nexport function clone(decoder: BinDecoder, newPos: number = decoder.pos): BinDecoder {\n  const _decoder = createDecoder(decoder.arr)\n  _decoder.pos = newPos\n  return _decoder\n}\n\n/**\n * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readUint8Array(decoder: BinDecoder, len: number): Uint8Array {\n  const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len)\n  decoder.pos += len\n  return view\n}\n\n/**\n * Read unsigned integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n */\nexport function readVarUint(decoder: BinDecoder): number {\n  let num = 0\n  let mult = 1\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    const r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult // shift $r << (7*#iterations) and add it to num\n    mult *= 128 // next iteration, shift 7 \"more\" to the left\n    if (r < BIT8)\n      return num\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Read variable length Uint8Array.\n *\n * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.\n *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.\n */\nexport function readVarUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, readVarUint(decoder))\n}\n\n/**\n * Read the rest of the content as an ArrayBuffer\n */\nexport function readTailAsUint8Array(decoder: BinDecoder): Uint8Array {\n  return readUint8Array(decoder, decoder.arr.length - decoder.pos)\n}\n\n/**\n * Skip one byte, jump to the next position.\n */\nexport function skip8(decoder: BinDecoder): number {\n  return decoder.pos++\n}\n\n/**\n * Read one byte as unsigned integer.\n */\nexport function readUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos++]\n}\n\n/**\n * Read 2 bytes as unsigned integer.\n */\nexport function readUint16(decoder: BinDecoder): number {\n  const uint = decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n  decoder.pos += 2\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer.\n */\nexport function readUint32(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Read 4 bytes as unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function readUint32BigEndian(decoder: BinDecoder): number {\n  const uint = (decoder.arr[decoder.pos + 3]\n    + (decoder.arr[decoder.pos + 2] << 8)\n    + (decoder.arr[decoder.pos + 1] << 16)\n    + (decoder.arr[decoder.pos] << 24)) >>> 0\n  decoder.pos += 4\n  return uint\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint8(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint16(decoder: BinDecoder): number {\n  return decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n}\n\n/**\n * Look ahead without incrementing the position\n * to the next byte and read it as unsigned integer.\n */\nexport function peekUint32(decoder: BinDecoder): number {\n  return (\n    decoder.arr[decoder.pos]\n    + (decoder.arr[decoder.pos + 1] << 8)\n    + (decoder.arr[decoder.pos + 2] << 16)\n    + (decoder.arr[decoder.pos + 3] << 24)\n  ) >>> 0\n}\n\n/**\n * Read signed integer (32bit) with variable length.\n * 1/8th of the storage is used as encoding overhead.\n * numbers < 2^7 is stored in one bytlength\n * numbers < 2^14 is stored in two bylength\n * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.\n */\nexport function readVarInt(decoder: BinDecoder): number {\n  let r = decoder.arr[decoder.pos++]\n  let num = r & BITS6\n  let mult = 64\n  const sign = (r & BIT7) > 0 ? -1 : 1 // use Math.sign(?) for performance?\n  if ((r & BIT8) === 0) {\n    // don't continue reading\n    return sign * num\n  }\n  const len = decoder.arr.length\n  while (decoder.pos < len) {\n    r = decoder.arr[decoder.pos++]\n    // num = num | ((r & binary.BITS7) << len)\n    num = num + (r & BITS7) * mult\n    mult *= 128\n    if (r < BIT8)\n      return sign * num\n\n    if (num > Number.MAX_SAFE_INTEGER)\n      throw new Error(errorIntegerOutOfRange)\n  }\n  throw new Error(errorUnexpectedEndOfArray)\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarUint(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarUint(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * Look ahead and read varUint without incrementing position\n */\nexport function peekVarInt(decoder: BinDecoder): number {\n  const pos = decoder.pos\n  const s = readVarInt(decoder)\n  decoder.pos = pos\n  return s\n}\n\n/**\n * We don't test this function anymore as we use native decoding/encoding by default now.\n * Better not modify this anymore..\n *\n * Transforming utf8 to a string is pretty expensive. The code performs 10x better\n * when String.fromCodePoint is fed with all characters as arguments.\n * But most environments have a maximum number of arguments per functions.\n * For effiency reasons we apply a maximum of 10000 characters at once.\n */\nfunction _readVarStringPolyfill(decoder: BinDecoder): string {\n  let remainingLen = readVarUint(decoder)\n  if (remainingLen === 0) {\n    return ''\n  }\n  else {\n    let encodedString = String.fromCodePoint(readUint8(decoder)) // remember to decrease remainingLen\n    if (--remainingLen < 100) { // do not create a Uint8Array for small strings\n      while (remainingLen--)\n        encodedString += String.fromCodePoint(readUint8(decoder))\n    }\n    else {\n      while (remainingLen > 0) {\n        const nextLen = remainingLen < 10000 ? remainingLen : 10000\n        // this is dangerous, we create a fresh array view from the existing buffer\n        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen)\n        decoder.pos += nextLen\n        // Starting with ES5.1 we can supply a generic array-like object as arguments\n        encodedString += String.fromCodePoint(...bytes as any)\n        remainingLen -= nextLen\n      }\n    }\n    return decodeURIComponent(escape(encodedString))\n  }\n}\n\n/**\n * Read string of variable length\n * varUint is used to store the length of the string\n */\nexport function readVarString(decoder: BinDecoder): string {\n  const utf8TextDecoder = getUtf8TextDecoder()\n  return utf8TextDecoder\n    ? utf8TextDecoder.decode(readVarUint8Array(decoder))\n    : _readVarStringPolyfill(decoder)\n}\n\n/**\n * Look ahead and read varString without incrementing position\n */\nexport function peekVarString(decoder: BinDecoder): string {\n  const pos = decoder.pos\n  const s = readVarString(decoder)\n  decoder.pos = pos\n  return s\n}\n\nexport function readFromDataView(decoder: BinDecoder, len: number): DataView {\n  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len)\n  decoder.pos += len\n  return dv\n}\n\nexport function readFloat32(decoder: BinDecoder) {\n  return readFromDataView(decoder, 4).getFloat32(0, false)\n}\n\nexport function readFloat64(decoder: BinDecoder) {\n  return readFromDataView(decoder, 8).getFloat64(0, false)\n}\n\nexport function readBigInt64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigInt64(0, false)\n}\n\nexport function readBigUint64(decoder: BinDecoder) {\n  return (readFromDataView(decoder, 8)).getBigUint64(0, false)\n}\n\nconst readAnyLookupTable: Array<((arg0: BinDecoder) => any)> = [\n  _ => undefined, // CASE 127: undefined\n  _ => null, // CASE 126: null\n  readVarInt, // CASE 125: integer\n  readFloat32, // CASE 124: float32\n  readFloat64, // CASE 123: float64\n  readBigInt64, // CASE 122: bigint\n  _ => false, // CASE 121: boolean (false)\n  _ => true, // CASE 120: boolean (true)\n  readVarString, // CASE 119: string\n  (decoder) => { // CASE 118: object<string,any>\n    const len = readVarUint(decoder)\n    const obj: { [s: string]: any } = {}\n    for (let i = 0; i < len; i++) {\n      const key = readVarString(decoder)\n      obj[key] = readAny(decoder)\n    }\n    return obj\n  },\n  (decoder) => { // CASE 117: array<any>\n    const len = readVarUint(decoder)\n    const arr = []\n    for (let i = 0; i < len; i++)\n\n      arr.push(readAny(decoder))\n\n    return arr\n  },\n  readVarUint8Array, // CASE 116: Uint8Array\n]\n\nexport function readAny(decoder: BinDecoder) {\n  return readAnyLookupTable[127 - readUint8(decoder)](decoder)\n}\n"],"mappings":"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"}