zeed 1.2.2 → 1.3.0

package/dist/common/bin/lib0/binary.d.mts

@@ -0,0 +1,80 @@
+//#region src/common/bin/lib0/binary.d.ts
+/**
+ * Original at https://github.com/dmonad/lib0
+ *
+ * Binary data constants.
+ */
+/**
+ * n-th bit activated.
+ */
+declare const BIT1 = 1;
+declare const BIT2 = 2;
+declare const BIT3 = 4;
+declare const BIT4 = 8;
+declare const BIT5 = 16;
+declare const BIT6 = 32;
+declare const BIT7 = 64;
+declare const BIT8 = 128;
+declare const BIT9 = 256;
+declare const BIT10 = 512;
+declare const BIT11 = 1024;
+declare const BIT12 = 2048;
+declare const BIT13 = 4096;
+declare const BIT14 = 8192;
+declare const BIT15 = 16384;
+declare const BIT16 = 32768;
+declare const BIT17 = 65536;
+declare const BIT18 = 131072;
+declare const BIT19 = 262144;
+declare const BIT20 = 524288;
+declare const BIT21 = 1048576;
+declare const BIT22 = 2097152;
+declare const BIT23 = 4194304;
+declare const BIT24 = 8388608;
+declare const BIT25 = 16777216;
+declare const BIT26 = 33554432;
+declare const BIT27 = 67108864;
+declare const BIT28 = 134217728;
+declare const BIT29 = 268435456;
+declare const BIT30 = 536870912;
+declare const BIT31 = 1073741824;
+declare const BIT32 = 2147483648;
+/**
+ * First n bits activated.
+ */
+declare const BITS0 = 0;
+declare const BITS1 = 1;
+declare const BITS2 = 3;
+declare const BITS3 = 7;
+declare const BITS4 = 15;
+declare const BITS5 = 31;
+declare const BITS6 = 63;
+declare const BITS7 = 127;
+declare const BITS8 = 255;
+declare const BITS9 = 511;
+declare const BITS10 = 1023;
+declare const BITS11 = 2047;
+declare const BITS12 = 4095;
+declare const BITS13 = 8191;
+declare const BITS14 = 16383;
+declare const BITS15 = 32767;
+declare const BITS16 = 65535;
+declare const BITS17 = 131071;
+declare const BITS18 = 262143;
+declare const BITS19 = 524287;
+declare const BITS20 = 1048575;
+declare const BITS21 = 2097151;
+declare const BITS22 = 4194303;
+declare const BITS23 = 8388607;
+declare const BITS24 = 16777215;
+declare const BITS25 = 33554431;
+declare const BITS26 = 67108863;
+declare const BITS27 = 134217727;
+declare const BITS28 = 268435455;
+declare const BITS29 = 536870911;
+declare const BITS30 = 1073741823;
+declare const BITS31 = 2147483647;
+declare const BITS32 = 4294967295;
+//#endregion
+export { BIT1, BIT10, BIT11, BIT12, BIT13, BIT14, BIT15, BIT16, BIT17, BIT18, BIT19, BIT2, BIT20, BIT21, BIT22, BIT23, BIT24, BIT25, BIT26, BIT27, BIT28, BIT29, BIT3, BIT30, BIT31, BIT32, BIT4, BIT5, BIT6, BIT7, BIT8, BIT9, BITS0, BITS1, BITS10, BITS11, BITS12, BITS13, BITS14, BITS15, BITS16, BITS17, BITS18, BITS19, BITS2, BITS20, BITS21, BITS22, BITS23, BITS24, BITS25, BITS26, BITS27, BITS28, BITS29, BITS3, BITS30, BITS31, BITS32, BITS4, BITS5, BITS6, BITS7, BITS8, BITS9 };
+//# sourceMappingURL=binary.d.mts.map

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

@@ -0,0 +1,2 @@
+const e=1,t=2,n=4,r=8,i=16,a=32,o=64,s=128,c=256,l=512,u=1024,d=2048,f=4096,p=8192,m=16384,h=32768,g=65536,_=131072,v=262144,y=524288,b=1048576,x=2097152,S=4194304,C=8388608,w=16777216,T=33554432,E=67108864,D=134217728,O=268435456,k=536870912,A=1073741824,j=2147483648,M=0,N=1,P=3,F=7,I=15,L=31,R=63,z=127,B=255,V=511,H=1023,U=2047,W=4095,G=8191,K=16383,q=32767,J=65535,Y=131071,X=262143,Z=524287,Q=1048575,$=2097151,ee=4194303,te=8388607,ne=16777215,re=33554431,ie=67108863,ae=134217727,oe=268435455,se=536870911,ce=1073741823,le=2147483647,ue=4294967295;export{e as BIT1,l as BIT10,u as BIT11,d as BIT12,f as BIT13,p as BIT14,m as BIT15,h as BIT16,g as BIT17,_ as BIT18,v as BIT19,t as BIT2,y as BIT20,b as BIT21,x as BIT22,S as BIT23,C as BIT24,w as BIT25,T as BIT26,E as BIT27,D as BIT28,O as BIT29,n as BIT3,k as BIT30,A as BIT31,j as BIT32,r as BIT4,i as BIT5,a as BIT6,o as BIT7,s as BIT8,c as BIT9,M as BITS0,N as BITS1,H as BITS10,U as BITS11,W as BITS12,G as BITS13,K as BITS14,q as BITS15,J as BITS16,Y as BITS17,X as BITS18,Z as BITS19,P as BITS2,Q as BITS20,$ as BITS21,ee as BITS22,te as BITS23,ne as BITS24,re as BITS25,ie as BITS26,ae as BITS27,oe as BITS28,se as BITS29,F as BITS3,ce as BITS30,le as BITS31,ue as BITS32,I as BITS4,L as BITS5,R as BITS6,z as BITS7,B as BITS8,V as BITS9};
+//# sourceMappingURL=binary.mjs.map

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

@@ -0,0 +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"}

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

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVR7T3I5Ncjs = require('../../../chunk-VR7T3I5N.cjs');var _chunkNVLJOTGFcjs = require('../../../chunk-NVLJOTGF.cjs');require('../../../chunk-JJKWFF7B.cjs');require('../../../chunk-L5XYQBG4.cjs');require('../../../chunk-4TLMJAZB.cjs');var _chunkP7XCQ7WVcjs = require('../../../chunk-P7XCQ7WV.cjs');function a(r){return new Uint8Array(r)}_chunkP7XCQ7WVcjs.a.call(void 0, a,"createUint8ArrayFromLen");function U(r){let n=a(r.byteLength);return n.set(r),n}_chunkP7XCQ7WVcjs.a.call(void 0, U,"copyUint8Array");function d(r){let n=_chunkVR7T3I5Ncjs.b.call(void 0, );return _chunkVR7T3I5Ncjs.A.call(void 0, n,r),_chunkVR7T3I5Ncjs.d.call(void 0, n)}_chunkP7XCQ7WVcjs.a.call(void 0, d,"encodeAny");function f(r){return _chunkNVLJOTGFcjs.A.call(void 0, _chunkNVLJOTGFcjs.b.call(void 0, r))}_chunkP7XCQ7WVcjs.a.call(void 0, f,"decodeAny");exports.copyUint8Array = U; exports.createUint8ArrayFromLen = a; exports.decodeAny = f; exports.encodeAny = d;
+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;
 //# sourceMappingURL=buffer.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/bin/lib0/buffer.cjs","../../../../src/common/bin/lib0/buffer.ts"],"names":["createUint8ArrayFromLen","len","__name","copyUint8Array","uint8Array","newBuf","encodeAny","data","encoder","createBinEncoder","writeAny","encodeToUint8Array","decodeAny","buf","readAny","createDecoder"],"mappings":"AAAA,wIAA6D,+DAAuD,uCAAoC,uCAAoC,uCAAoC,+DAAgD,SCShQA,CAAAA,CAAwBC,CAAAA,CAAyB,CAC/D,OAAO,IAAI,UAAA,CAAWA,CAAG,CAC3B,CAFgBC,iCAAAA,CAAAF,CAAA,yBAAA,CAAA,CAOT,SAASG,CAAAA,CAAeC,CAAAA,CAAoC,CACjE,IAAMC,CAAAA,CAASL,CAAAA,CAAwBI,CAAAA,CAAW,UAAU,CAAA,CAC5D,OAAAC,CAAAA,CAAO,GAAA,CAAID,CAAU,CAAA,CACdC,CACT,CAJgBH,iCAAAA,CAAAC,CAAA,gBAAA,CAAA,CAUT,SAASG,CAAAA,CAAUC,CAAAA,CAAuB,CAC/C,IAAMC,CAAAA,CAAUC,iCAAAA,CAAiB,CACjC,OAAAC,iCAAAA,CAASF,CAASD,CAAI,CAAA,CACfI,iCAAAA,CAA0B,CACnC,CAJgBT,iCAAAA,CAAAI,CAAA,WAAA,CAAA,CAST,SAASM,CAAAA,CAAUC,CAAAA,CAAsB,CAC9C,OAAOC,iCAAAA,iCAAQC,CAAiB,CAAC,CACnC,CAFgBb,iCAAAA,CAAAU,CAAA,WAAA,CAAA,CAAA,8GAAA","file":"/Users/dirk/work/github-zeed/dist/common/bin/lib0/buffer.cjs","sourcesContent":[null,"/**\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"]}
+{"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"}

package/dist/common/bin/lib0/buffer.d.cts

@@ -1,3 +1,4 @@
+//#region src/common/bin/lib0/buffer.d.ts
 /**
  * Original at https://github.com/dmonad/lib0
  *
@@ -17,5 +18,6 @@ declare function encodeAny(data: any): Uint8Array;
  * Decode an any-encoded value.
  */
 declare function decodeAny(buf: Uint8Array): any;
-
+//#endregion
 export { copyUint8Array, createUint8ArrayFromLen, decodeAny, encodeAny };
+//# sourceMappingURL=buffer.d.cts.map

package/dist/common/bin/lib0/buffer.d.mts

@@ -0,0 +1,23 @@
+//#region src/common/bin/lib0/buffer.d.ts
+/**
+ * Original at https://github.com/dmonad/lib0
+ *
+ * Utility functions to work with buffers (Uint8Array).
+ */
+declare function createUint8ArrayFromLen(len: number): Uint8Array;
+/**
+ * Copy the content of an Uint8Array view to a new ArrayBuffer.
+ */
+declare function copyUint8Array(uint8Array: Uint8Array): Uint8Array;
+/**
+ * Encode anything as a UInt8Array. It's a pun on typescripts's `any` type.
+ * See encoding.writeAny for more information.
+ */
+declare function encodeAny(data: any): Uint8Array;
+/**
+ * Decode an any-encoded value.
+ */
+declare function decodeAny(buf: Uint8Array): any;
+//#endregion
+export { copyUint8Array, createUint8ArrayFromLen, decodeAny, encodeAny };
+//# sourceMappingURL=buffer.d.mts.map

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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=buffer.mjs.map

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

@@ -0,0 +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"}

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

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk4TLMJAZBcjs = require('../../../chunk-4TLMJAZB.cjs');require('../../../chunk-P7XCQ7WV.cjs');exports.createUint8ArrayFromArrayBuffer = _chunk4TLMJAZBcjs.b; exports.createUint8ArrayViewFromArrayBuffer = _chunk4TLMJAZBcjs.a;
+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;
 //# sourceMappingURL=create.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/bin/lib0/create.cjs"],"names":[],"mappings":"AAAA,wIAA4C,uCAAoC,iIAAsF","file":"/Users/dirk/work/github-zeed/dist/common/bin/lib0/create.cjs"}
+{"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"}

package/dist/common/bin/lib0/create.d.cts

@@ -1,3 +1,4 @@
+//#region src/common/bin/lib0/create.d.ts
 /**
  * Original at https://github.com/dmonad/lib0
  *
@@ -11,5 +12,6 @@ declare function createUint8ArrayViewFromArrayBuffer(buffer: ArrayBufferLike, by
  * Create Uint8Array with initial content from buffer
  */
 declare function createUint8ArrayFromArrayBuffer(buffer: ArrayBuffer): Uint8Array<ArrayBuffer>;
-
+//#endregion
 export { createUint8ArrayFromArrayBuffer, createUint8ArrayViewFromArrayBuffer };
+//# sourceMappingURL=create.d.cts.map

package/dist/common/bin/lib0/create.d.mts

@@ -0,0 +1,17 @@
+//#region src/common/bin/lib0/create.d.ts
+/**
+ * Original at https://github.com/dmonad/lib0
+ *
+ * Utility functions to work with buffers (Uint8Array).
+ */
+/**
+ * Create Uint8Array with initial content from buffer
+ */
+declare function createUint8ArrayViewFromArrayBuffer(buffer: ArrayBufferLike, byteOffset: number, length: number): Uint8Array<ArrayBufferLike>;
+/**
+ * Create Uint8Array with initial content from buffer
+ */
+declare function createUint8ArrayFromArrayBuffer(buffer: ArrayBuffer): Uint8Array<ArrayBuffer>;
+//#endregion
+export { createUint8ArrayFromArrayBuffer, createUint8ArrayViewFromArrayBuffer };
+//# sourceMappingURL=create.d.mts.map

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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=create.mjs.map

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

@@ -0,0 +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"}

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

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkNVLJOTGFcjs = require('../../../chunk-NVLJOTGF.cjs');require('../../../chunk-JJKWFF7B.cjs');require('../../../chunk-L5XYQBG4.cjs');require('../../../chunk-4TLMJAZB.cjs');require('../../../chunk-P7XCQ7WV.cjs');exports.BinDecoder = _chunkNVLJOTGFcjs.a; exports.clone = _chunkNVLJOTGFcjs.d; exports.createDecoder = _chunkNVLJOTGFcjs.b; exports.hasContent = _chunkNVLJOTGFcjs.c; exports.peekUint16 = _chunkNVLJOTGFcjs.o; exports.peekUint32 = _chunkNVLJOTGFcjs.p; exports.peekUint8 = _chunkNVLJOTGFcjs.n; exports.peekVarInt = _chunkNVLJOTGFcjs.s; exports.peekVarString = _chunkNVLJOTGFcjs.u; exports.peekVarUint = _chunkNVLJOTGFcjs.r; exports.readAny = _chunkNVLJOTGFcjs.A; exports.readBigInt64 = _chunkNVLJOTGFcjs.y; exports.readBigUint64 = _chunkNVLJOTGFcjs.z; exports.readFloat32 = _chunkNVLJOTGFcjs.w; exports.readFloat64 = _chunkNVLJOTGFcjs.x; exports.readFromDataView = _chunkNVLJOTGFcjs.v; exports.readTailAsUint8Array = _chunkNVLJOTGFcjs.h; exports.readUint16 = _chunkNVLJOTGFcjs.k; exports.readUint32 = _chunkNVLJOTGFcjs.l; exports.readUint32BigEndian = _chunkNVLJOTGFcjs.m; exports.readUint8 = _chunkNVLJOTGFcjs.j; exports.readUint8Array = _chunkNVLJOTGFcjs.e; exports.readVarInt = _chunkNVLJOTGFcjs.q; exports.readVarString = _chunkNVLJOTGFcjs.t; exports.readVarUint = _chunkNVLJOTGFcjs.f; exports.readVarUint8Array = _chunkNVLJOTGFcjs.g; exports.skip8 = _chunkNVLJOTGFcjs.i;
+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;
 //# sourceMappingURL=decoding.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/bin/lib0/decoding.cjs"],"names":[],"mappings":"AAAA,wIAA8F,uCAAoC,uCAAoC,uCAAoC,uCAAoC,opCAA+d","file":"/Users/dirk/work/github-zeed/dist/common/bin/lib0/decoding.cjs"}
+{"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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"}

package/dist/common/bin/lib0/decoding.d.cts

@@ -1,3 +1,4 @@
+//#region src/common/bin/lib0/decoding.d.ts
 /**
  * Original at https://github.com/dmonad/lib0
  *
@@ -29,11 +30,11 @@
  * A BinDecoder handles the decoding of an Uint8Array.
  */
 declare class BinDecoder {
-    /** Decoding target. */
-    arr: Uint8Array;
-    /** Current decoding position. */
-    pos: number;
-    constructor(uint8Array: Uint8Array);
+  /** Decoding target. */
+  arr: Uint8Array;
+  /** Current decoding position. */
+  pos: number;
+  constructor(uint8Array: Uint8Array);
 }
 declare function createDecoder(uint8Array: Uint8Array): BinDecoder;
 declare function hasContent(decoder: BinDecoder): boolean;
@@ -134,5 +135,6 @@ declare function readFloat64(decoder: BinDecoder): number;
 declare function readBigInt64(decoder: BinDecoder): bigint;
 declare function readBigUint64(decoder: BinDecoder): bigint;
 declare function readAny(decoder: BinDecoder): any;
-
+//#endregion
 export { BinDecoder, clone, createDecoder, hasContent, peekUint16, peekUint32, peekUint8, peekVarInt, peekVarString, peekVarUint, readAny, readBigInt64, readBigUint64, readFloat32, readFloat64, readFromDataView, readTailAsUint8Array, readUint16, readUint32, readUint32BigEndian, readUint8, readUint8Array, readVarInt, readVarString, readVarUint, readVarUint8Array, skip8 };
+//# sourceMappingURL=decoding.d.cts.map

package/dist/common/bin/lib0/decoding.d.mts

@@ -0,0 +1,140 @@
+//#region src/common/bin/lib0/decoding.d.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
+ * ```
+ */
+/**
+ * A BinDecoder handles the decoding of an Uint8Array.
+ */
+declare class BinDecoder {
+  /** Decoding target. */
+  arr: Uint8Array;
+  /** Current decoding position. */
+  pos: number;
+  constructor(uint8Array: Uint8Array);
+}
+declare function createDecoder(uint8Array: Uint8Array): BinDecoder;
+declare function hasContent(decoder: BinDecoder): boolean;
+/**
+ * Clone a decoder instance.
+ * Optionally set a new position parameter.
+ */
+declare function clone(decoder: BinDecoder, newPos?: number): BinDecoder;
+/**
+ * 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.
+ */
+declare function readUint8Array(decoder: BinDecoder, len: number): Uint8Array;
+/**
+ * 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
+ */
+declare function readVarUint(decoder: BinDecoder): number;
+/**
+ * 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.
+ */
+declare function readVarUint8Array(decoder: BinDecoder): Uint8Array;
+/**
+ * Read the rest of the content as an ArrayBuffer
+ */
+declare function readTailAsUint8Array(decoder: BinDecoder): Uint8Array;
+/**
+ * Skip one byte, jump to the next position.
+ */
+declare function skip8(decoder: BinDecoder): number;
+/**
+ * Read one byte as unsigned integer.
+ */
+declare function readUint8(decoder: BinDecoder): number;
+/**
+ * Read 2 bytes as unsigned integer.
+ */
+declare function readUint16(decoder: BinDecoder): number;
+/**
+ * Read 4 bytes as unsigned integer.
+ */
+declare function readUint32(decoder: BinDecoder): number;
+/**
+ * Read 4 bytes as unsigned integer in big endian order.
+ * (most significant byte first)
+ */
+declare function readUint32BigEndian(decoder: BinDecoder): number;
+/**
+ * Look ahead without incrementing the position
+ * to the next byte and read it as unsigned integer.
+ */
+declare function peekUint8(decoder: BinDecoder): number;
+/**
+ * Look ahead without incrementing the position
+ * to the next byte and read it as unsigned integer.
+ */
+declare function peekUint16(decoder: BinDecoder): number;
+/**
+ * Look ahead without incrementing the position
+ * to the next byte and read it as unsigned integer.
+ */
+declare function peekUint32(decoder: BinDecoder): number;
+/**
+ * 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.
+ */
+declare function readVarInt(decoder: BinDecoder): number;
+/**
+ * Look ahead and read varUint without incrementing position
+ */
+declare function peekVarUint(decoder: BinDecoder): number;
+/**
+ * Look ahead and read varUint without incrementing position
+ */
+declare function peekVarInt(decoder: BinDecoder): number;
+/**
+ * Read string of variable length
+ * varUint is used to store the length of the string
+ */
+declare function readVarString(decoder: BinDecoder): string;
+/**
+ * Look ahead and read varString without incrementing position
+ */
+declare function peekVarString(decoder: BinDecoder): string;
+declare function readFromDataView(decoder: BinDecoder, len: number): DataView;
+declare function readFloat32(decoder: BinDecoder): number;
+declare function readFloat64(decoder: BinDecoder): number;
+declare function readBigInt64(decoder: BinDecoder): bigint;
+declare function readBigUint64(decoder: BinDecoder): bigint;
+declare function readAny(decoder: BinDecoder): any;
+//#endregion
+export { BinDecoder, clone, createDecoder, hasContent, peekUint16, peekUint32, peekUint8, peekVarInt, peekVarString, peekVarUint, readAny, readBigInt64, readBigUint64, readFloat32, readFloat64, readFromDataView, readTailAsUint8Array, readUint16, readUint32, readUint32BigEndian, readUint8, readUint8Array, readVarInt, readVarString, readVarUint, readVarUint8Array, skip8 };
+//# sourceMappingURL=decoding.d.mts.map

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

@@ -0,0 +1,2 @@
+import"./binary.mjs";import{createUint8ArrayViewFromArrayBuffer as e}from"./create.mjs";import{getUtf8TextDecoder as t}from"./string.mjs";const 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(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();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)}export{i as BinDecoder,s as clone,a as createDecoder,o as hasContent,v as peekUint16,y as peekUint32,_ as peekUint8,S as peekVarInt,T as peekVarString,x as peekVarUint,M as readAny,k as readBigInt64,A as readBigUint64,D as readFloat32,O as readFloat64,E as readFromDataView,d as readTailAsUint8Array,m as readUint16,h as readUint32,g as readUint32BigEndian,p as readUint8,c as readUint8Array,b as readVarInt,w as readVarString,l as readVarUint,u as readVarUint8Array,f as skip8};
+//# sourceMappingURL=decoding.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decoding.mjs","names":[],"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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"}

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

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVR7T3I5Ncjs = require('../../../chunk-VR7T3I5N.cjs');require('../../../chunk-JJKWFF7B.cjs');require('../../../chunk-L5XYQBG4.cjs');require('../../../chunk-4TLMJAZB.cjs');require('../../../chunk-P7XCQ7WV.cjs');exports.BinEncoder = _chunkVR7T3I5Ncjs.a; exports.createBinEncoder = _chunkVR7T3I5Ncjs.b; exports.encodeToUint8Array = _chunkVR7T3I5Ncjs.d; exports.isNegativeZero = _chunkVR7T3I5Ncjs.p; exports.length = _chunkVR7T3I5Ncjs.c; exports.set = _chunkVR7T3I5Ncjs.g; exports.setUint16 = _chunkVR7T3I5Ncjs.k; exports.setUint32 = _chunkVR7T3I5Ncjs.n; exports.setUint8 = _chunkVR7T3I5Ncjs.i; exports.verifyLen = _chunkVR7T3I5Ncjs.e; exports.write = _chunkVR7T3I5Ncjs.f; exports.writeAny = _chunkVR7T3I5Ncjs.A; exports.writeBigInt64 = _chunkVR7T3I5Ncjs.y; exports.writeBigUint64 = _chunkVR7T3I5Ncjs.z; exports.writeBinaryEncoder = _chunkVR7T3I5Ncjs.u; exports.writeFloat32 = _chunkVR7T3I5Ncjs.w; exports.writeFloat64 = _chunkVR7T3I5Ncjs.x; exports.writeOnDataView = _chunkVR7T3I5Ncjs.v; exports.writeUint16 = _chunkVR7T3I5Ncjs.j; exports.writeUint32 = _chunkVR7T3I5Ncjs.l; exports.writeUint32BigEndian = _chunkVR7T3I5Ncjs.m; exports.writeUint8 = _chunkVR7T3I5Ncjs.h; exports.writeUint8Array = _chunkVR7T3I5Ncjs.r; exports.writeVarInt = _chunkVR7T3I5Ncjs.q; exports.writeVarString = _chunkVR7T3I5Ncjs.t; exports.writeVarUint = _chunkVR7T3I5Ncjs.o; exports.writeVarUint8Array = _chunkVR7T3I5Ncjs.s;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`./binary.cjs`);const e=require(`./create.cjs`),t=require(`./string.cjs`);var n=class{cpos;cbuf;bufs;constructor(){this.cpos=0,this.cbuf=new Uint8Array(100),this.bufs=[]}};function r(){return new n}function i(e){let t=e.cpos;for(let n=0;n<e.bufs.length;n++)t+=e.bufs[n].length;return t}function a(t){let n=new Uint8Array(i(t)),r=0;for(let e=0;e<t.bufs.length;e++){let i=t.bufs[e];n.set(i,r),r+=i.length}return n.set(e.createUint8ArrayViewFromArrayBuffer(t.cbuf.buffer,0,t.cpos),r),n}function o(t,n){let r=t.cbuf.length;r-t.cpos<n&&(t.bufs.push(e.createUint8ArrayViewFromArrayBuffer(t.cbuf.buffer,0,t.cpos)),t.cbuf=new Uint8Array(Math.max(r,n)*2),t.cpos=0)}function s(e,t){let n=e.cbuf.length;e.cpos===n&&(e.bufs.push(e.cbuf),e.cbuf=new Uint8Array(n*2),e.cpos=0),e.cbuf[e.cpos++]=t}function c(e,t,n){let r=null;for(let n=0;n<e.bufs.length&&r===null;n++){let i=e.bufs[n];t<i.length?r=i:t-=i.length}r===null&&(r=e.cbuf),r[t]=n}const l=s,u=c;function d(e,t){s(e,t&255),s(e,t>>>8&255)}function f(e,t,n){c(e,t,n&255),c(e,t+1,n>>>8&255)}function p(e,t){for(let n=0;n<4;n++)s(e,t&255),t>>>=8}function m(e,t){for(let n=3;n>=0;n--)s(e,t>>>8*n&255)}function h(e,t,n){for(let r=0;r<4;r++)c(e,t+r,n&255),n>>>=8}function g(e,t){for(;t>127;)s(e,128|127&t),t=Math.floor(t/128);s(e,127&t)}function _(e){return e===0?1/e<0:e<0}function v(e,t){let n=_(t);for(n&&(t=-t),s(e,(t>63?128:0)|(n?64:0)|63&t),t=Math.floor(t/64);t>0;)s(e,(t>127?128:0)|127&t),t=Math.floor(t/128)}function y(e,t){let n=e.cbuf.length,r=e.cpos,i=Math.min(n-r,t.length),a=t.length-i;e.cbuf.set(t.subarray(0,i),r),e.cpos+=i,a>0&&(e.bufs.push(e.cbuf),e.cbuf=new Uint8Array(Math.max(n*2,a)),e.cbuf.set(t.subarray(i)),e.cpos=a)}function b(e,t){g(e,t.byteLength),y(e,t)}let x,S;function C(e,n){if(x??(x=new Uint8Array(3e4),S=x.length/3),n.length<S){let r=t.getUtf8TextEncoder().encodeInto(n,x).written||0;g(e,r);for(let t=0;t<r;t++)s(e,x[t])}else b(e,t.encodeUtf8(n))}function w(e,t){let n=unescape(encodeURIComponent(t)),r=n.length;g(e,r);for(let t=0;t<r;t++)s(e,n.codePointAt(t))}function T(e,n){return t.getUtf8TextEncoder()?.encodeInto?C(e,n):w(e,n)}function E(e,t){return y(e,a(t))}function D(e,t){o(e,t);let n=new DataView(e.cbuf.buffer,e.cpos,t);return e.cpos+=t,n}function O(e,t){return D(e,4).setFloat32(0,t,!1)}function k(e,t){return D(e,8).setFloat64(0,t,!1)}function A(e,t){return D(e,8).setBigInt64(0,t,!1)}function j(e,t){return D(e,8).setBigUint64(0,t,!1)}let M;function N(e){return M??=new DataView(new ArrayBuffer(4)),M.setFloat32(0,e),M.getFloat32(0)===e}function P(e,t){switch(typeof t){case`string`:s(e,119),T(e,t);break;case`number`:Number.isInteger(t)&&Math.abs(t)<=2147483647?(s(e,125),v(e,t)):N(t)?(s(e,124),O(e,t)):(s(e,123),k(e,t));break;case`bigint`:s(e,122),A(e,t);break;case`object`:if(t===null)s(e,126);else if(Array.isArray(t)){s(e,117),g(e,t.length);for(let n=0;n<t.length;n++)P(e,t[n])}else if(t instanceof Uint8Array)s(e,116),b(e,t);else{s(e,118);let n=Object.keys(t);n.sort(),g(e,n.length);for(let r=0;r<n.length;r++){let i=n[r];T(e,i),P(e,t[i])}}break;case`boolean`:s(e,t?120:121);break;default:s(e,127)}}exports.BinEncoder=n,exports.createBinEncoder=r,exports.encodeToUint8Array=a,exports.isNegativeZero=_,exports.length=i,exports.set=c,exports.setUint16=f,exports.setUint32=h,exports.setUint8=u,exports.verifyLen=o,exports.write=s,exports.writeAny=P,exports.writeBigInt64=A,exports.writeBigUint64=j,exports.writeBinaryEncoder=E,exports.writeFloat32=O,exports.writeFloat64=k,exports.writeOnDataView=D,exports.writeUint16=d,exports.writeUint32=p,exports.writeUint32BigEndian=m,exports.writeUint8=l,exports.writeUint8Array=y,exports.writeVarInt=v,exports.writeVarString=T,exports.writeVarUint=g,exports.writeVarUint8Array=b;
 //# sourceMappingURL=encoding.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/bin/lib0/encoding.cjs"],"names":[],"mappings":"AAAA,wIAA8F,uCAAoC,uCAAoC,uCAAoC,uCAAoC,gqCAA2e","file":"/Users/dirk/work/github-zeed/dist/common/bin/lib0/encoding.cjs"}
+{"version":3,"file":"encoding.cjs","names":["createUint8ArrayViewFromArrayBuffer","getUtf8TextEncoder","encodeUtf8"],"sources":["../../../../src/common/bin/lib0/encoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary encoding with support for variable length encoding.\n *\n * Use [lib0/encoding] with [lib0/decoding]. 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, BITS8, BITS31 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { encodeUtf8, getUtf8TextEncoder } from './string'\n\n/**\n * A BinaryEncoder handles the encoding to an Uint8Array.\n */\nexport class BinEncoder {\n  cpos: number\n  cbuf: Uint8Array\n  bufs: Uint8Array[]\n\n  constructor() {\n    this.cpos = 0\n    this.cbuf = new Uint8Array(100)\n    this.bufs = []\n  }\n}\n\nexport function createBinEncoder(): BinEncoder {\n  return new BinEncoder()\n}\n\n/**\n * The current length of the encoded data.\n */\nexport function length(encoder: BinEncoder): number {\n  let len = encoder.cpos\n  for (let i = 0; i < encoder.bufs.length; i++)\n    len += encoder.bufs[i].length\n\n  return len\n}\n\n/**\n * Transform to Uint8Array.\n */\nexport function encodeToUint8Array(encoder: BinEncoder): Uint8Array {\n  const uint8arr = new Uint8Array(length(encoder))\n  let curPos = 0\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    const d = encoder.bufs[i]\n    uint8arr.set(d, curPos)\n    curPos += d.length\n  }\n  uint8arr.set(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos), curPos)\n  return uint8arr\n}\n\n/**\n * Verify that it is possible to write `len` bytes wtihout checking. If\n * necessary, a new Buffer with the required length is attached.\n */\nexport function verifyLen(encoder: BinEncoder, len: number) {\n  const bufferLen = encoder.cbuf.length\n  if (bufferLen - encoder.cpos < len) {\n    encoder.bufs.push(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos))\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen, len) * 2)\n    encoder.cpos = 0\n  }\n}\n\n/**\n * Write one byte to the encoder.\n */\nexport function write(encoder: BinEncoder, num: number) {\n  const bufferLen = encoder.cbuf.length\n  if (encoder.cpos === bufferLen) {\n    encoder.bufs.push(encoder.cbuf)\n    encoder.cbuf = new Uint8Array(bufferLen * 2)\n    encoder.cpos = 0\n  }\n  encoder.cbuf[encoder.cpos++] = num\n}\n\n/**\n * Write one byte at a specific position.\n * Position must already be written (i.e. encoder.length > pos)\n */\nexport function set(encoder: BinEncoder, pos: number, num: number) {\n  let buffer = null\n  // iterate all buffers and adjust position\n  for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {\n    const b = encoder.bufs[i]\n    if (pos < b.length)\n      buffer = b // found buffer\n\n    else\n      pos -= b.length\n  }\n  if (buffer === null) {\n    // use current buffer\n    buffer = encoder.cbuf\n  }\n  buffer[pos] = num\n}\n\n/**\n * Write one byte as an unsigned integer.\n */\nexport const writeUint8 = write\n\n/**\n * Write one byte as an unsigned Integer at a specific location.\n */\nexport const setUint8 = set\n\n/**\n * Write two bytes as an unsigned integer.\n */\nexport function writeUint16(encoder: BinEncoder, num: number) {\n  write(encoder, num & BITS8)\n  write(encoder, (num >>> 8) & BITS8)\n}\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint16(encoder: BinEncoder, pos: number, num: number) {\n  set(encoder, pos, num & BITS8)\n  set(encoder, pos + 1, (num >>> 8) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer\n */\nexport function writeUint32(encoder: BinEncoder, num: number) {\n  for (let i = 0; i < 4; i++) {\n    write(encoder, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function writeUint32BigEndian(encoder: BinEncoder, num: number) {\n  for (let i = 3; i >= 0; i--)\n    write(encoder, (num >>> (8 * i)) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint32(encoder: BinEncoder, pos: number, num: number) {\n  for (let i = 0; i < 4; i++) {\n    set(encoder, pos + i, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write a variable length unsigned integer. Max encodable integer is 2^53.\n */\nexport function writeVarUint(encoder: BinEncoder, num: number) {\n  while (num > BITS7) {\n    write(encoder, BIT8 | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n  write(encoder, BITS7 & num)\n}\n\nexport function isNegativeZero(n: number) {\n  return n !== 0 ? n < 0 : 1 / n < 0\n}\n\n/**\n * Write a variable length integer.\n *\n * We use the 7th bit instead for signaling that this is a negative number.\n */\nexport function writeVarInt(encoder: BinEncoder, num: number) {\n  const isNegative = isNegativeZero(num)\n  if (isNegative)\n    num = -num\n\n  //             |- whether to continue reading         |- whether is negative     |- number\n  write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | (BITS6 & num))\n  num = Math.floor(num / 64) // shift >>> 6\n\n  // We don't need to consider the case of num === 0 so we can use a different\n  // pattern here than above.\n  while (num > 0) {\n    write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n}\n\n/**\n * Append fixed-length Uint8Array to the encoder.\n */\nexport function writeUint8Array(encoder: BinEncoder, uint8Array: Uint8Array) {\n  const bufferLen = encoder.cbuf.length\n  const cpos = encoder.cpos\n  const leftCopyLen = Math.min(bufferLen - cpos, uint8Array.length)\n  const rightCopyLen = uint8Array.length - leftCopyLen\n  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos)\n  encoder.cpos += leftCopyLen\n  if (rightCopyLen > 0) {\n    // Still something to write, write right half..\n    // Append new buffer\n    encoder.bufs.push(encoder.cbuf)\n    // must have at least size of remaining buffer\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen * 2, rightCopyLen))\n    // copy array\n    encoder.cbuf.set(uint8Array.subarray(leftCopyLen))\n    encoder.cpos = rightCopyLen\n  }\n}\n\n/**\n * Append an Uint8Array to BinEncoder.\n */\nexport function writeVarUint8Array(encoder: BinEncoder, uint8Array: Uint8Array): void {\n  writeVarUint(encoder, uint8Array.byteLength)\n  writeUint8Array(encoder, uint8Array)\n}\n\n/**\n * A cache to store strings temporarily\n */\nlet _strBuffer: Uint8Array\nlet _maxStrBSize: number\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringNative(encoder: BinEncoder, str: string) {\n  if (_strBuffer == null) {\n    _strBuffer = new Uint8Array(30000)\n    _maxStrBSize = _strBuffer.length / 3\n  }\n\n  if (str.length < _maxStrBSize) {\n    // We can encode the string into the existing buffer\n    const written = getUtf8TextEncoder()!.encodeInto(str, _strBuffer).written || 0\n    writeVarUint(encoder, written)\n    for (let i = 0; i < written; i++)\n      write(encoder, _strBuffer[i])\n  }\n  else {\n    writeVarUint8Array(encoder, encodeUtf8(str))\n  }\n}\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringPolyfill(encoder: BinEncoder, str: string) {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++)\n    write(encoder, (encodedString.codePointAt(i) as number))\n}\n\n/**\n * Write a variable length string.\n */\nexport function writeVarString(encoder: BinEncoder, str: string) {\n  return getUtf8TextEncoder()?.encodeInto\n    ? _writeVarStringNative(encoder, str)\n    : _writeVarStringPolyfill(encoder, str)\n}\n\n/**\n * Write the content of another Encoder.\n *\n * @TODO: can be improved!\n *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.\n *                Encoders start with a rather big initial buffer.\n */\nexport function writeBinaryEncoder(encoder: BinEncoder, append: BinEncoder) {\n  return writeUint8Array(encoder, encodeToUint8Array(append))\n}\n\n/**\n * Create an DataView of the next `len` bytes. Use it to write data after\n * calling this function.\n *\n * ```js\n * // write float32 using DataView\n * const dv = writeOnDataView(encoder, 4)\n * dv.setFloat32(0, 1.1)\n * // read float32 using DataView\n * const dv = readFromDataView(encoder, 4)\n * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)\n * ```\n */\nexport function writeOnDataView(encoder: BinEncoder, len: number): DataView {\n  verifyLen(encoder, len)\n  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len)\n  encoder.cpos += len\n  return dview\n}\n\nexport function writeFloat32(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 4).setFloat32(0, num, false)\n}\n\nexport function writeFloat64(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 8).setFloat64(0, num, false)\n}\n\nexport function writeBigInt64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigInt64(0, num, false)\n}\n\nexport function writeBigUint64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigUint64(0, num, false)\n}\n\nlet floatTestBed: DataView\n\n/**\n * Check if a number can be encoded as a 32 bit float.\n */\nfunction isFloat32(num: number): boolean {\n  floatTestBed ??= new DataView(new ArrayBuffer(4))\n  floatTestBed.setFloat32(0, num)\n  return floatTestBed.getFloat32(0) === num\n}\n\n/**\n * Encode data with efficient binary format.\n *\n * Differences to JSON:\n * • Transforms data to a binary format (not to a string)\n * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)\n * • Numbers are efficiently encoded either as a variable length integer, as a\n *   32 bit float, as a 64 bit float, or as a 64 bit bigint.\n *\n * Encoding table:\n *\n * | Data Type           | Prefix   | Encoding Method    | Comment |\n * | ------------------- | -------- | ------------------ | ------- |\n * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |\n * | null                | 126      |                    | |\n * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |\n * | float32             | 124      | writeFloat32       | |\n * | float64             | 123      | writeFloat64       | |\n * | bigint              | 122      | writeBigInt64      | |\n * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |\n * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |\n * | string              | 119      | writeVarString     | |\n * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |\n * | array<any>          | 117      | custom             | Writes {length} then {length} json values |\n * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |\n *\n * Reasons for the decreasing prefix:\n * We need the first bit for extendability (later we may want to encode the\n * prefix with writeVarUint). The remaining 7 bits are divided as follows:\n * [0-30]   the beginning of the data range is used for custom purposes\n *          (defined by the function that uses this library)\n * [31-127] the end of the data range is used for data encoding by\n *          lib0/encoding.js\n */\nexport function writeAny(encoder: BinEncoder, data: undefined | null | number | bigint | boolean | string | { [s: string]: any } | Array<any> | Uint8Array) {\n  switch (typeof data) {\n    case 'string':\n      // TYPE 119: STRING\n      write(encoder, 119)\n      writeVarString(encoder, data)\n      break\n    case 'number':\n      if (Number.isInteger(data) && Math.abs(data) <= BITS31) {\n        // TYPE 125: INTEGER\n        write(encoder, 125)\n        writeVarInt(encoder, data)\n      }\n      else if (isFloat32(data)) {\n        // TYPE 124: FLOAT32\n        write(encoder, 124)\n        writeFloat32(encoder, data)\n      }\n      else {\n        // TYPE 123: FLOAT64\n        write(encoder, 123)\n        writeFloat64(encoder, data)\n      }\n      break\n    case 'bigint':\n      // TYPE 122: BigInt\n      write(encoder, 122)\n      writeBigInt64(encoder, data)\n      break\n    case 'object':\n      if (data === null) {\n        // TYPE 126: null\n        write(encoder, 126)\n      }\n      else if (Array.isArray(data)) {\n        // TYPE 117: Array\n        write(encoder, 117)\n        writeVarUint(encoder, data.length)\n        for (let i = 0; i < data.length; i++)\n          writeAny(encoder, data[i])\n      }\n      else if (data instanceof Uint8Array) {\n        // TYPE 116: ArrayBuffer\n        write(encoder, 116)\n        writeVarUint8Array(encoder, data)\n      }\n      else {\n        // TYPE 118: Object\n        write(encoder, 118)\n        const keys = Object.keys(data)\n        keys.sort() // guarantee comparability and consistency\n        writeVarUint(encoder, keys.length)\n        for (let i = 0; i < keys.length; i++) {\n          const key = keys[i]\n          writeVarString(encoder, key)\n          writeAny(encoder, data[key])\n        }\n      }\n      break\n    case 'boolean':\n      // TYPE 120/121: boolean (true/false)\n      write(encoder, data ? 120 : 121)\n      break\n    default:\n      // TYPE 127: undefined\n      write(encoder, 127)\n  }\n}\n"],"mappings":"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"}

package/dist/common/bin/lib0/encoding.d.cts

@@ -1,3 +1,4 @@
+//#region src/common/bin/lib0/encoding.d.ts
 /**
  * Original at https://github.com/dmonad/lib0
  *
@@ -29,10 +30,10 @@
  * A BinaryEncoder handles the encoding to an Uint8Array.
  */
 declare class BinEncoder {
-    cpos: number;
-    cbuf: Uint8Array;
-    bufs: Uint8Array[];
-    constructor();
+  cpos: number;
+  cbuf: Uint8Array;
+  bufs: Uint8Array[];
+  constructor();
 }
 declare function createBinEncoder(): BinEncoder;
 /**
@@ -170,7 +171,8 @@ declare function writeBigUint64(encoder: BinEncoder, num: bigint): void;
  *          lib0/encoding.js
  */
 declare function writeAny(encoder: BinEncoder, data: undefined | null | number | bigint | boolean | string | {
-    [s: string]: any;
+  [s: string]: any;
 } | Array<any> | Uint8Array): void;
-
+//#endregion
 export { BinEncoder, createBinEncoder, encodeToUint8Array, isNegativeZero, length, set, setUint16, setUint32, setUint8, verifyLen, write, writeAny, writeBigInt64, writeBigUint64, writeBinaryEncoder, writeFloat32, writeFloat64, writeOnDataView, writeUint16, writeUint32, writeUint32BigEndian, writeUint8, writeUint8Array, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array };
+//# sourceMappingURL=encoding.d.cts.map