zeed 1.2.4 → 1.3.1

package/dist/chunk-FGAKPO3O.js

@@ -1,2 +0,0 @@
-import{e as h,f as U}from"./chunk-ESODSJEY.js";import{M as x,N as l,O as u,g as S,h as B,ja as T}from"./chunk-6GMDX4A4.js";import{a as w}from"./chunk-VF3ZWSJS.js";import{a as r}from"./chunk-5NKC2EQJ.js";var y=class{static{r(this,"BinEncoder")}cpos;cbuf;bufs;constructor(){this.cpos=0,this.cbuf=new Uint8Array(100),this.bufs=[]}};function R(){return new y}r(R,"createBinEncoder");function k(t){let n=t.cpos;for(let i=0;i<t.bufs.length;i++)n+=t.bufs[i].length;return n}r(k,"length");function F(t){let n=new Uint8Array(k(t)),i=0;for(let e=0;e<t.bufs.length;e++){let o=t.bufs[e];n.set(o,i),i+=o.length}return n.set(w(t.cbuf.buffer,0,t.cpos),i),n}r(F,"encodeToUint8Array");function L(t,n){let i=t.cbuf.length;i-t.cpos<n&&(t.bufs.push(w(t.cbuf.buffer,0,t.cpos)),t.cbuf=new Uint8Array(Math.max(i,n)*2),t.cpos=0)}r(L,"verifyLen");function f(t,n){let i=t.cbuf.length;t.cpos===i&&(t.bufs.push(t.cbuf),t.cbuf=new Uint8Array(i*2),t.cpos=0),t.cbuf[t.cpos++]=n}r(f,"write");function p(t,n,i){let e=null;for(let o=0;o<t.bufs.length&&e===null;o++){let s=t.bufs[o];n<s.length?e=s:n-=s.length}e===null&&(e=t.cbuf),e[n]=i}r(p,"set");var Z=f,q=p;function G(t,n){f(t,n&255),f(t,n>>>8&255)}r(G,"writeUint16");function H(t,n,i){p(t,n,i&255),p(t,n+1,i>>>8&255)}r(H,"setUint16");function J(t,n){for(let i=0;i<4;i++)f(t,n&255),n>>>=8}r(J,"writeUint32");function K(t,n){for(let i=3;i>=0;i--)f(t,n>>>8*i&255)}r(K,"writeUint32BigEndian");function Q(t,n,i){for(let e=0;e<4;e++)p(t,n+e,i&255),i>>>=8}r(Q,"setUint32");function c(t,n){for(;n>127;)f(t,128|127&n),n=Math.floor(n/128);f(t,127&n)}r(c,"writeVarUint");function M(t){return t!==0?t<0:1/t<0}r(M,"isNegativeZero");function v(t,n){let i=M(n);for(i&&(n=-n),f(t,(n>63?128:0)|(i?64:0)|63&n),n=Math.floor(n/64);n>0;)f(t,(n>127?128:0)|127&n),n=Math.floor(n/128)}r(v,"writeVarInt");function I(t,n){let i=t.cbuf.length,e=t.cpos,o=Math.min(i-e,n.length),s=n.length-o;t.cbuf.set(n.subarray(0,o),e),t.cpos+=o,s>0&&(t.bufs.push(t.cbuf),t.cbuf=new Uint8Array(Math.max(i*2,s)),t.cbuf.set(n.subarray(o)),t.cpos=s)}r(I,"writeUint8Array");function V(t,n){c(t,n.byteLength),I(t,n)}r(V,"writeVarUint8Array");var b,E;function D(t,n){if(b==null&&(b=new Uint8Array(3e4),E=b.length/3),n.length<E){let i=h().encodeInto(n,b).written||0;c(t,i);for(let e=0;e<i;e++)f(t,b[e])}else V(t,U(n))}r(D,"_writeVarStringNative");function N(t,n){let i=unescape(encodeURIComponent(n)),e=i.length;c(t,e);for(let o=0;o<e;o++)f(t,i.codePointAt(o))}r(N,"_writeVarStringPolyfill");function A(t,n){return h()?.encodeInto?D(t,n):N(t,n)}r(A,"writeVarString");function W(t,n){return I(t,F(n))}r(W,"writeBinaryEncoder");function g(t,n){L(t,n);let i=new DataView(t.cbuf.buffer,t.cpos,n);return t.cpos+=n,i}r(g,"writeOnDataView");function _(t,n){return g(t,4).setFloat32(0,n,!1)}r(_,"writeFloat32");function C(t,n){return g(t,8).setFloat64(0,n,!1)}r(C,"writeFloat64");function P(t,n){return g(t,8).setBigInt64(0,n,!1)}r(P,"writeBigInt64");function X(t,n){return g(t,8).setBigUint64(0,n,!1)}r(X,"writeBigUint64");var a;function j(t){return a==null&&(a=new DataView(new ArrayBuffer(4))),a.setFloat32(0,t),a.getFloat32(0)===t}r(j,"isFloat32");function m(t,n){switch(typeof n){case"string":f(t,119),A(t,n);break;case"number":Number.isInteger(n)&&Math.abs(n)<=2147483647?(f(t,125),v(t,n)):j(n)?(f(t,124),_(t,n)):(f(t,123),C(t,n));break;case"bigint":f(t,122),P(t,n);break;case"object":if(n===null)f(t,126);else if(Array.isArray(n)){f(t,117),c(t,n.length);for(let i=0;i<n.length;i++)m(t,n[i])}else if(n instanceof Uint8Array)f(t,116),V(t,n);else{f(t,118);let i=Object.keys(n);i.sort(),c(t,i.length);for(let e=0;e<i.length;e++){let o=i[e];A(t,o),m(t,n[o])}}break;case"boolean":f(t,n?120:121);break;default:f(t,127)}}r(m,"writeAny");export{y as a,R as b,k as c,F as d,L as e,f,p as g,Z as h,q as i,G as j,H as k,J as l,K as m,Q as n,c as o,M as p,v as q,I as r,V as s,A as t,W as u,g as v,_ as w,C as x,P as y,X as z,m as A};
-//# sourceMappingURL=chunk-FGAKPO3O.js.map

package/dist/chunk-FGAKPO3O.js.map

@@ -1 +0,0 @@
-{"version":3,"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  if (floatTestBed == null)\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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","names":["BinEncoder","__name","createBinEncoder","length","encoder","len","encodeToUint8Array","uint8arr","curPos","i","d","createUint8ArrayViewFromArrayBuffer","verifyLen","bufferLen","write","num","set","pos","buffer","b","writeUint8","setUint8","writeUint16","setUint16","writeUint32","writeUint32BigEndian","setUint32","writeVarUint","isNegativeZero","n","writeVarInt","isNegative","writeUint8Array","uint8Array","cpos","leftCopyLen","rightCopyLen","writeVarUint8Array","_strBuffer","_maxStrBSize","_writeVarStringNative","str","written","getUtf8TextEncoder","encodeUtf8","_writeVarStringPolyfill","encodedString","writeVarString","writeBinaryEncoder","append","writeOnDataView","dview","writeFloat32","writeFloat64","writeBigInt64","writeBigUint64","floatTestBed","isFloat32","writeAny","data","keys","key"]}

package/dist/chunk-FGCCHFKO.js

@@ -1,2 +0,0 @@
-import{a as o}from"./chunk-5NKC2EQJ.js";var u=/\\\s|\s+|#[^\n]*\n?/g,d=/\(\?P?<(\w{2,})>|\((?!\?([:!=]|<=|<!))/g,c=/^((?:\(\?[\w$]+\))?)\(\?<([=!])([\s\S]*?)\)/gm;function a(r){return typeof r=="string"?r:r.source||""}o(a,"regExpString");function f(r){return r.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&")}o(f,"regExpEscape");var h=class{static{o(this,"XRX")}lookBehind;namedGroups={};names=[];rx;constructor(t,e){let s=e??"",n;if(t instanceof RegExp?(e==null&&(s=t.flags),n=t.source):n=t,s&&s.includes("x")&&(s=s.replace("x",""),n=n.replace(u,x=>x[0]==="\\"?x:"")),!(t instanceof RegExp)){let x=0;n=n.replace(d,(g,l)=>(x+=1,l?(l!=="index"&&l!=="length"&&!this.namedGroups[l]&&(this.namedGroups[l]=x),"("):g)),this.names=Object.keys(this.namedGroups)}n=a(n),c.lastIndex=0;let i=c.exec(n);i&&(this.lookBehind={rx:new RegExp(`${i[3]}$(?!\\s)`),expect:i?i[2]==="=":!i},n=n.substr(i[0].length)),this.rx=new RegExp(n,s)}get lastIndex(){return this.rx.lastIndex}set lastIndex(t){this.rx.lastIndex=t}_handleMatch(t){if(this.lookBehind){let e=t.input.slice(0,t.index);if(this.lookBehind.expect!==this.lookBehind.rx.test(e))return null}for(let e of this.names)t[e]=t[this.namedGroups[e]];return t}exec(t){let e;for(;e=this.rx.exec(t);)if(this.rx.lastIndex===e.index&&this.rx.lastIndex++,e=this._handleMatch(e),e!=null)return e}execAll(t){let e=[],s;for(this.rx.lastIndex=0;s=this.exec(t);)e.push(s);return this.rx.lastIndex=0,e}replace(t,e){let s=typeof e=="function"?e:()=>e;return t.replace(this.rx,n=>s(n))}};export{a,f as b,h as c};
-//# sourceMappingURL=chunk-FGCCHFKO.js.map

package/dist/chunk-FGCCHFKO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/data/xrx.ts"],"sourcesContent":["/* eslint-disable no-cond-assign */\n\nconst RX_WHITESPACE = /\\\\\\s|\\s+|#[^\\n]*\\n?/g\nconst RX_REAL_GROUPS = /\\(\\?P?<(\\w{2,})>|\\((?!\\?([:!=]|<=|<!))/g\n// eslint-disable-next-line regexp/no-unused-capturing-group\nconst RX_LOOK_BEHIND = /^((?:\\(\\?[\\w$]+\\))?)\\(\\?<([=!])([\\s\\S]*?)\\)/gm\n\nexport function regExpString(rx: string | RegExp): string {\n  return typeof rx === 'string' ? rx : (rx.source || '')\n}\n\nexport function regExpEscape(str: string): string {\n  return str.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&')\n}\n\nexport class XRX {\n  lookBehind:any\n  namedGroups: Record<string, number> = {}\n  names: string[] = []\n  rx: RegExp\n\n  constructor(pattern: string | RegExp, flags?: string) {\n    let _flags: string = flags ?? ''\n    let _rx: string\n\n    if (pattern instanceof RegExp) {\n      if (flags == null)\n        _flags = pattern.flags\n\n      _rx = pattern.source\n    }\n    else {\n      _rx = pattern\n    }\n\n    // eXtended / Ignore Whitespace\n    const extended = _flags && _flags.includes('x')\n    if (extended) {\n      _flags = _flags.replace('x', '')\n      _rx = _rx.replace(RX_WHITESPACE, (r) => {\n        // log('rp', r)\n        return r[0] === '\\\\' ? r : ''\n      })\n    }\n\n    // Named Groups\n    if (!(pattern instanceof RegExp)) {\n      let index = 0\n      _rx = _rx.replace(RX_REAL_GROUPS, (str, name) => {\n        // log('>>>', name)\n        index += 1\n        if (name) {\n          if (\n            name !== 'index'\n            && name !== 'length'\n            && !this.namedGroups[name]\n          ) {\n            this.namedGroups[name] = index\n          }\n          // else\n          //   log.error(`Unallowed or duplicate group name: ${name}`)\n\n          return '('\n        }\n        return str\n      })\n      this.names = Object.keys(this.namedGroups)\n    }\n\n    // http://www.rexegg.com/regex-best-trick.html\n\n    _rx = regExpString(_rx)\n    RX_LOOK_BEHIND.lastIndex = 0\n    const parts = RX_LOOK_BEHIND.exec(_rx)\n    if (parts) {\n      this.lookBehind = {\n        rx: new RegExp(`${parts[3]}$(?!\\\\s)`),\n        expect: parts ? parts[2] === '=' : !parts,\n      }\n      _rx = _rx.substr(parts[0].length)\n    }\n\n    this.rx = new RegExp(_rx, _flags)\n  }\n\n  // flagsString() {\n  //     let hash = this.rx.toString() + '/'\n  //     if (this.rx.global) {\n  //         hash += 'g'\n  //     }\n  //     if (this.rx.multiline) {\n  //         hash += 'm'\n  //     }\n  //     if (this.rx.ignoreCase) {\n  //         hash += 'i'\n  //     }\n  //     if (this.rx.unicode) {\n  //         hash += 'u'\n  //     }\n  //     if (this.rx.sticky) {\n  //         hash += 'y'\n  //     }\n  // }\n\n  get lastIndex(): number {\n    return this.rx.lastIndex\n  }\n\n  set lastIndex(index: number) {\n    this.rx.lastIndex = index\n  }\n\n  _handleMatch(m: any) {\n    if (this.lookBehind) {\n      const leftContext = m.input.slice(0, m.index)\n      if (this.lookBehind.expect !== this.lookBehind.rx.test(leftContext))\n        return null\n    }\n    for (const name of this.names)\n      m[name] = m[this.namedGroups[name]]\n\n    return m\n  }\n\n  exec(str: string) {\n    let m\n    while ((m = this.rx.exec(str))) {\n      if (this.rx.lastIndex === m.index)\n        this.rx.lastIndex++\n      m = this._handleMatch(m)\n      if (m != null)\n        return m\n    }\n  }\n\n  execAll(str: string) {\n    const matches = []\n    let m\n    this.rx.lastIndex = 0\n    while ((m = this.exec(str)))\n      matches.push(m)\n\n    this.rx.lastIndex = 0\n    // log('execAll:', matches)\n    return matches\n  }\n\n  replace(str: string, replacement: string | ((m: string) => string)) {\n    const fn = typeof replacement === 'function' ? replacement : () => replacement\n    return str.replace(this.rx, (m) => {\n      // m = this._handleMatch(m)\n      return fn(m)\n    })\n  }\n}\n"],"mappings":"wCAEA,IAAMA,EAAgB,uBAChBC,EAAiB,0CAEjBC,EAAiB,gDAEhB,SAASC,EAAaC,EAA6B,CACxD,OAAO,OAAOA,GAAO,SAAWA,EAAMA,EAAG,QAAU,EACrD,CAFgBC,EAAAF,EAAA,gBAIT,SAASG,EAAaC,EAAqB,CAChD,OAAOA,EAAI,QAAQ,2BAA4B,MAAM,CACvD,CAFgBF,EAAAC,EAAA,gBAIT,IAAME,EAAN,KAAU,CAfjB,MAeiB,CAAAH,EAAA,YACf,WACA,YAAsC,CAAC,EACvC,MAAkB,CAAC,EACnB,GAEA,YAAYI,EAA0BC,EAAgB,CACpD,IAAIC,EAAiBD,GAAS,GAC1BE,EAuBJ,GArBIH,aAAmB,QACjBC,GAAS,OACXC,EAASF,EAAQ,OAEnBG,EAAMH,EAAQ,QAGdG,EAAMH,EAISE,GAAUA,EAAO,SAAS,GAAG,IAE5CA,EAASA,EAAO,QAAQ,IAAK,EAAE,EAC/BC,EAAMA,EAAI,QAAQZ,EAAgBa,GAEzBA,EAAE,CAAC,IAAM,KAAOA,EAAI,EAC5B,GAIC,EAAEJ,aAAmB,QAAS,CAChC,IAAIK,EAAQ,EACZF,EAAMA,EAAI,QAAQX,EAAgB,CAACM,EAAKQ,KAEtCD,GAAS,EACLC,GAEAA,IAAS,SACNA,IAAS,UACT,CAAC,KAAK,YAAYA,CAAI,IAEzB,KAAK,YAAYA,CAAI,EAAID,GAKpB,KAEFP,EACR,EACD,KAAK,MAAQ,OAAO,KAAK,KAAK,WAAW,CAC3C,CAIAK,EAAMT,EAAaS,CAAG,EACtBV,EAAe,UAAY,EAC3B,IAAMc,EAAQd,EAAe,KAAKU,CAAG,EACjCI,IACF,KAAK,WAAa,CAChB,GAAI,IAAI,OAAO,GAAGA,EAAM,CAAC,CAAC,UAAU,EACpC,OAAQA,EAAQA,EAAM,CAAC,IAAM,IAAM,CAACA,CACtC,EACAJ,EAAMA,EAAI,OAAOI,EAAM,CAAC,EAAE,MAAM,GAGlC,KAAK,GAAK,IAAI,OAAOJ,EAAKD,CAAM,CAClC,CAqBA,IAAI,WAAoB,CACtB,OAAO,KAAK,GAAG,SACjB,CAEA,IAAI,UAAUG,EAAe,CAC3B,KAAK,GAAG,UAAYA,CACtB,CAEA,aAAaG,EAAQ,CACnB,GAAI,KAAK,WAAY,CACnB,IAAMC,EAAcD,EAAE,MAAM,MAAM,EAAGA,EAAE,KAAK,EAC5C,GAAI,KAAK,WAAW,SAAW,KAAK,WAAW,GAAG,KAAKC,CAAW,EAChE,OAAO,IACX,CACA,QAAWH,KAAQ,KAAK,MACtBE,EAAEF,CAAI,EAAIE,EAAE,KAAK,YAAYF,CAAI,CAAC,EAEpC,OAAOE,CACT,CAEA,KAAKV,EAAa,CAChB,IAAIU,EACJ,KAAQA,EAAI,KAAK,GAAG,KAAKV,CAAG,GAI1B,GAHI,KAAK,GAAG,YAAcU,EAAE,OAC1B,KAAK,GAAG,YACVA,EAAI,KAAK,aAAaA,CAAC,EACnBA,GAAK,KACP,OAAOA,CAEb,CAEA,QAAQV,EAAa,CACnB,IAAMY,EAAU,CAAC,EACbF,EAEJ,IADA,KAAK,GAAG,UAAY,EACZA,EAAI,KAAK,KAAKV,CAAG,GACvBY,EAAQ,KAAKF,CAAC,EAEhB,YAAK,GAAG,UAAY,EAEbE,CACT,CAEA,QAAQZ,EAAaa,EAA+C,CAClE,IAAMC,EAAK,OAAOD,GAAgB,WAAaA,EAAc,IAAMA,EACnE,OAAOb,EAAI,QAAQ,KAAK,GAAKU,GAEpBI,EAAGJ,CAAC,CACZ,CACH,CACF","names":["RX_WHITESPACE","RX_REAL_GROUPS","RX_LOOK_BEHIND","regExpString","rx","__name","regExpEscape","str","XRX","pattern","flags","_flags","_rx","r","index","name","parts","m","leftContext","matches","replacement","fn"]}

package/dist/chunk-FLFB2K34.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-FLFB2K34.js.map

package/dist/chunk-FLFB2K34.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-FMMEBQFR.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _chunkLUPESR7Scjs = require('./chunk-LUPESR7S.cjs');var _chunkOGP3AZFMcjs = require('./chunk-OGP3AZFM.cjs');var _chunkTNMEWZPWcjs = require('./chunk-TNMEWZPW.cjs');var _chunkZEDMMWJIcjs = require('./chunk-ZEDMMWJI.cjs');var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');var o=16;function a(){return _chunkLUPESR7Scjs.a.call(void 0, o)}_chunkP7XCQ7WVcjs.a.call(void 0, a,"uuidBytes");function $(t=a()){return _chunkOGP3AZFMcjs.i.call(void 0, t,22)}_chunkP7XCQ7WVcjs.a.call(void 0, $,"uuidB62");function w(t){return _chunkOGP3AZFMcjs.i.call(void 0, t,22)}_chunkP7XCQ7WVcjs.a.call(void 0, w,"uuidEncodeB62");function h(t){return _chunkOGP3AZFMcjs.j.call(void 0, t,o)}_chunkP7XCQ7WVcjs.a.call(void 0, h,"uuidDecodeB62");function M(t=a()){return _chunkOGP3AZFMcjs.c.call(void 0, t,26)}_chunkP7XCQ7WVcjs.a.call(void 0, M,"uuidB32");function v(t){return _chunkOGP3AZFMcjs.c.call(void 0, t,26)}_chunkP7XCQ7WVcjs.a.call(void 0, v,"uuidEncodeB32");function F(t){return _chunkOGP3AZFMcjs.d.call(void 0, t,o)}_chunkP7XCQ7WVcjs.a.call(void 0, F,"uuidDecodeB32");function I(){if(typeof crypto<"u"&&crypto.randomUUID!=null)return crypto.randomUUID();let t=_chunkLUPESR7Scjs.a.call(void 0, 16);return t[6]=t[6]&15|64,t[8]=t[8]&63|128,m(t)}_chunkP7XCQ7WVcjs.a.call(void 0, I,"uuidv4");function m(t){let r=_chunkTNMEWZPWcjs.J.call(void 0, t);return`${r.slice(0,8)}-${r.slice(8,12)}-${r.slice(12,16)}-${r.slice(16,20)}-${r.slice(20)}`}_chunkP7XCQ7WVcjs.a.call(void 0, m,"uuidEncodeV4");function V(t){return _chunkTNMEWZPWcjs.K.call(void 0, t.replace(/-/g,""))}_chunkP7XCQ7WVcjs.a.call(void 0, V,"uuidDecodeV4");var D=16e11;function _(t){let r=new Uint8Array(6);for(let n=5;n>=0;n--)r[n]=t&255,t=Math.floor(t/256);return r}_chunkP7XCQ7WVcjs.a.call(void 0, _,"longToByteArray");function b(){let t=_chunkZEDMMWJIcjs.b.call(void 0, )-D,r=new Uint8Array(16);return r.set(_(t),0),r.set(_chunkLUPESR7Scjs.a.call(void 0, 10),6),r}_chunkP7XCQ7WVcjs.a.call(void 0, b,"suidBytes");function j(){return T(b())}_chunkP7XCQ7WVcjs.a.call(void 0, j,"suid");function z(t){return R(E(t))}_chunkP7XCQ7WVcjs.a.call(void 0, z,"suidDate");function R(t){return new Date(D+t.slice(0,6).reduce((r,n)=>r*256+n,0))}_chunkP7XCQ7WVcjs.a.call(void 0, R,"suidBytesDate");function G(){let t=_chunkLUPESR7Scjs.a.call(void 0, 4);return new DataView(t.buffer,t.byteOffset,t.byteLength).getUint32(0,!1)}_chunkP7XCQ7WVcjs.a.call(void 0, G,"uuid32bit");var f={base62:{uuid:$,uuidDecode:h,uuidEncode:w},base32:{uuid:M,uuidDecode:F,uuidEncode:v},uuidv4:{uuid:I,uuidDecode:V,uuidEncode:m},test:{uuid:_chunkP7XCQ7WVcjs.a.call(void 0, ()=>k("test"),"uuid"),uuidDecode:_chunkP7XCQ7WVcjs.a.call(void 0, t=>_chunkTNMEWZPWcjs.G.call(void 0, t),"uuidDecode"),uuidEncode:_chunkP7XCQ7WVcjs.a.call(void 0, t=>_chunkTNMEWZPWcjs.E.call(void 0, t),"uuidEncode")}},d="base62",B=!1;function J(t,r=!1){t==="test"&&q("test"),d=_nullishCoalesce(t, () => ("base62")),B=r}_chunkP7XCQ7WVcjs.a.call(void 0, J,"setUuidDefaultEncoding");function K(){return f[d].uuid(B?b():a())}_chunkP7XCQ7WVcjs.a.call(void 0, K,"uuid");function E(t){return f[d].uuidDecode(t)}_chunkP7XCQ7WVcjs.a.call(void 0, E,"uuidDecode");function T(t){return f[d].uuidEncode(t)}_chunkP7XCQ7WVcjs.a.call(void 0, T,"uuidEncode");function N(t){try{return E(t).length===o}catch (e2){}return!1}_chunkP7XCQ7WVcjs.a.call(void 0, N,"uuidIsValid");var u={};function k(t="id"){return u[t]==null&&(u[t]=0),`${t}-${u[t]++}`}_chunkP7XCQ7WVcjs.a.call(void 0, k,"uname");function q(t="id"){u[t]=0}_chunkP7XCQ7WVcjs.a.call(void 0, q,"unameReset");var H=0;function P(){return`id-${H++}`}_chunkP7XCQ7WVcjs.a.call(void 0, P,"qid");exports.a = a; exports.b = $; exports.c = w; exports.d = h; exports.e = M; exports.f = v; exports.g = F; exports.h = I; exports.i = m; exports.j = V; exports.k = b; exports.l = j; exports.m = z; exports.n = R; exports.o = G; exports.p = J; exports.q = K; exports.r = E; exports.s = T; exports.t = N; exports.u = k; exports.v = q; exports.w = P;
-//# sourceMappingURL=chunk-FMMEBQFR.cjs.map

package/dist/chunk-FMMEBQFR.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-FMMEBQFR.cjs","../src/common/uuid.ts"],"names":["uuidBytesLength","uuidBytes","randomUint8Array","__name","uuidB62","bytes","encodeBase62","uuidEncodeB62","uuidDecodeB62","uuid","decodeBase62","uuidB32","encodeBase32","uuidEncodeB32","uuidDecodeB32","decodeBase32","uuidv4","uuidEncodeV4","id","toHex"],"mappings":"AAAA,qOAAwC,wDAA8D,wDAA8D,wDAAyC,wDAAyC,ICOhPA,CAAAA,CAAkB,EAAA,CAUjB,SAASC,CAAAA,CAAAA,CAAwB,CACtC,OAAOC,iCAAAA,CAAgC,CACzC,CAFgBC,iCAAAA,CAAAF,CAAA,WAAA,CAAA,CAaT,SAASG,CAAAA,CAAQC,CAAAA,CAAoBJ,CAAAA,CAAU,CAAA,CAAW,CAC/D,OAAOK,iCAAAA,CAAaD,CAAO,EAAE,CAC/B,CAFgBF,iCAAAA,CAAAC,CAAA,SAAA,CAAA,CAUT,SAASG,CAAAA,CAAcF,CAAAA,CAA2B,CACvD,OAAOC,iCAAAA,CAAaD,CAAO,EAAE,CAC/B,CAFgBF,iCAAAA,CAAAI,CAAA,eAAA,CAAA,CAUT,SAASC,CAAAA,CAAcC,CAAAA,CAA0B,CACtD,OAAOC,iCAAAA,CAAaD,CAAMT,CAAe,CAC3C,CAFgBG,iCAAAA,CAAAK,CAAA,eAAA,CAAA,CAYT,SAASG,CAAAA,CAAQN,CAAAA,CAAoBJ,CAAAA,CAAU,CAAA,CAAW,CAC/D,OAAOW,iCAAAA,CAAaP,CAAO,EAAE,CAC/B,CAFgBF,iCAAAA,CAAAQ,CAAA,SAAA,CAAA,CAUT,SAASE,CAAAA,CAAcR,CAAAA,CAA2B,CACvD,OAAOO,iCAAAA,CAAaP,CAAO,EAAE,CAC/B,CAFgBF,iCAAAA,CAAAU,CAAA,eAAA,CAAA,CAUT,SAASC,CAAAA,CAAcL,CAAAA,CAA0B,CACtD,OAAOM,iCAAAA,CAAaN,CAAMT,CAAe,CAC3C,CAFgBG,iCAAAA,CAAAW,CAAA,eAAA,CAAA,CAiBT,SAASE,CAAAA,CAAAA,CAAiB,CAC/B,EAAA,CAAI,OAAO,MAAA,CAAW,GAAA,EAAe,MAAA,CAAO,UAAA,EAAc,IAAA,CACxD,OAAO,MAAA,CAAO,UAAA,CAAW,CAAA,CAG3B,IAAMX,CAAAA,CAAQH,iCAAAA,EAAmB,CAAA,CACjC,OAAAG,CAAAA,CAAM,CAAC,CAAA,CAAKA,CAAAA,CAAM,CAAC,CAAA,CAAI,EAAA,CAAQ,EAAA,CAC/BA,CAAAA,CAAM,CAAC,CAAA,CAAKA,CAAAA,CAAM,CAAC,CAAA,CAAI,EAAA,CAAQ,GAAA,CACxBY,CAAAA,CAAaZ,CAAK,CAC3B,CATgBF,iCAAAA,CAAAa,CAAA,QAAA,CAAA,CAiBT,SAASC,CAAAA,CAAaZ,CAAAA,CAA2B,CACtD,IAAMa,CAAAA,CAAKC,iCAAAA,CAAW,CAAA,CACtB,MAAO,CAAA,EAAA","file":"/Users/dirk/work/github-zeed/dist/chunk-FMMEBQFR.cjs","sourcesContent":[null,"import { randomUint8Array } from './crypto'\nimport { decodeBase32, decodeBase62, encodeBase32, encodeBase62 } from './data/basex'\nimport { fromHex, toHex, toUint8Array, Uint8ArrayToString } from './data/bin'\nimport { getTimestamp } from './time'\n\n// 128 bit UUID\n\nconst uuidBytesLength = 16\n\n/**\n * Generate raw UUID bytes (128 bits / 16 bytes).\n *\n * Uses a cryptographically secure random source provided by\n * `randomUint8Array`.\n *\n * @returns Uint8Array of length 16 with random bytes\n */\nexport function uuidBytes(): Uint8Array {\n  return randomUint8Array(uuidBytesLength)\n}\n\n// Base62\n\n/**\n * Create a Base62-encoded UUID string from the provided bytes or a newly\n * generated random UUID. The result is a compact, URL-safe identifier.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base62 string representation (22 characters)\n */\nexport function uuidB62(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Encode raw UUID bytes to a Base62 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base62-encoded string\n */\nexport function uuidEncodeB62(bytes: Uint8Array): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Decode a Base62-encoded UUID string into raw bytes.\n *\n * @param uuid - Base62 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB62(uuid: string): Uint8Array {\n  return decodeBase62(uuid, uuidBytesLength)\n}\n\n// Base32\n\n/**\n * Create a Base32-encoded UUID string from bytes or a new random UUID.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base32 string representation (26 characters)\n */\nexport function uuidB32(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Encode raw UUID bytes to a Base32 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base32-encoded string\n */\nexport function uuidEncodeB32(bytes: Uint8Array): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Decode a Base32-encoded UUID string into raw bytes.\n *\n * @param uuid - Base32 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB32(uuid: string): Uint8Array {\n  return decodeBase32(uuid, uuidBytesLength)\n}\n\n// UUIDv4\n\n// https://stackoverflow.com/a/2117523/140927\nconst pattern = '10000000-1000-4000-8000-100000000000' // String([1e7] + -1e3 + -4e3 + -8e3 + -1e11)\n\n/**\n * Generate a UUID v4 string.\n *\n * Uses the native `crypto.randomUUID()` if available; otherwise falls back to\n * a random-based implementation using `randomUint8Array`.\n *\n * @returns UUID v4 string in standard 8-4-4-4-12 hex format\n */\nexport function uuidv4(): string {\n  if (typeof crypto !== 'undefined' && crypto.randomUUID != null)\n    return crypto.randomUUID() // native!\n\n  // Fallback: generate 16 random bytes, set version and variant bits per RFC-4122\n  const bytes = randomUint8Array(16)\n  bytes[6] = (bytes[6] & 0x0F) | 0x40 // version 4\n  bytes[8] = (bytes[8] & 0x3F) | 0x80 // variant\n  return uuidEncodeV4(bytes)\n}\n\n/**\n * Encode 16 raw bytes as a UUID v4 formatted string (hex with dashes).\n *\n * @param bytes - 16-byte Uint8Array\n * @returns UUID string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)\n */\nexport function uuidEncodeV4(bytes: Uint8Array): string {\n  const id = toHex(bytes)\n  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}` // 10000000 - 1000 - 4000 - 8000 - 100000000000\n}\n\n/**\n * Decode a UUID v4 string (hex with dashes) into raw bytes.\n *\n * @param uuid - UUID string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeV4(uuid: string): Uint8Array {\n  return fromHex(uuid.replace(/-/g, ''))\n}\n\n// Sortable UID\n\n// https://github.com/segmentio/ksuid\n// https://pkg.go.dev/github.com/rsms/go-uuid\n\n/**\n * Sortable unique ID\n * Inspired by https://github.com/rsms/go-uuid\n *\n * Bytes 0-5:  Current time in miliseconds from 2021-06-01T00:00:00Z\n * Bytes 6-15: Random\n */\n\n// 1622505600000 //  new Date('2021-06-01T00:00:00Z').getTime()\nconst ReferenceDateInMS = 1600000000000\n\n// 6 bytes will stay valid until end of time: new Date(1622505600000 + 0xffffffffffff) === Date Sun Jan 01 10941 06:31:50 GMT+0100 (Central European Standard Time)\n\nfunction longToByteArray(long: number) {\n  const byteArray = new Uint8Array(6)\n  for (let i = 5; i >= 0; i--) {\n    byteArray[i] = long & 0xFF\n    long = Math.floor(long / 256)\n  }\n  return byteArray\n}\n\n// function byteArrayToLong(byteArray: number[]): number {\n//   var value = 0\n//   for (var i = byteArray.length - 1; i >= 0; i--) {\n//     value = value * 256 + byteArray[i]\n//   }\n//   return value\n// }\n\n/**\n * Create a sortable unique identifier (SUID) as raw bytes.\n *\n * The first 6 bytes encode a millisecond timestamp offset from an internal\n * reference date to allow lexicographic sorting by creation time. The\n * remaining 10 bytes are random.\n *\n * @returns 16-byte Uint8Array where bytes 0-5 are timestamp and 6-15 are random\n */\nexport function suidBytes(): Uint8Array {\n  const ms = getTimestamp() - ReferenceDateInMS\n  const out = new Uint8Array(16)\n  out.set(longToByteArray(ms), 0)\n  out.set(randomUint8Array(10), 6)\n  return out\n}\n\n/**\n * Create a sortable unique identifier (SUID) and return it encoded using the\n * currently configured UUID encoding.\n *\n * @returns encoded SUID string\n */\nexport function suid(): string {\n  return uuidEncode(suidBytes())\n}\n\n/**\n * Extract the creation Date from an encoded SUID string.\n *\n * @param id - encoded SUID\n * @returns Date corresponding to the timestamp component of the SUID\n */\nexport function suidDate(id: string): Date {\n  return suidBytesDate(uuidDecode(id))\n}\n\n/**\n * Extract the creation Date from raw SUID bytes.\n *\n * @param id - 16-byte SUID as Uint8Array\n * @returns Date corresponding to the timestamp encoded in bytes 0-5\n */\nexport function suidBytesDate(id: Uint8Array): Date {\n  return new Date(\n    ReferenceDateInMS + id.slice(0, 6).reduce((acc, byte) => acc * 256 + byte, 0),\n  )\n}\n\n// 32 bit UUID\n\n/**\n * Generate a 32-bit unsigned integer from 4 random bytes.\n *\n * @returns a random 32-bit unsigned integer\n */\nexport function uuid32bit(): number {\n  const bytes = randomUint8Array(4)\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n  return view.getUint32(0, false)\n}\n\n// Global Settings\n\nconst mapModes = {\n  base62: {\n    uuid: uuidB62,\n    uuidDecode: uuidDecodeB62,\n    uuidEncode: uuidEncodeB62,\n  },\n  base32: {\n    uuid: uuidB32,\n    uuidDecode: uuidDecodeB32,\n    uuidEncode: uuidEncodeB32,\n  },\n  uuidv4: {\n    uuid: uuidv4,\n    uuidDecode: uuidDecodeV4,\n    uuidEncode: uuidEncodeV4,\n  },\n  test: {\n    uuid: (): string => uname('test'),\n    uuidDecode: (id: string): Uint8Array => toUint8Array(id),\n    uuidEncode: (bin: Uint8Array): string => Uint8ArrayToString(bin),\n  },\n}\n\nlet _mode: keyof typeof mapModes = 'base62'\nlet _sorted = false\n\n/**\n * Configure the default encoding and whether generated IDs should be\n * lexicographically sortable.\n *\n * @param mode - encoding mode ('base62' | 'base32' | 'uuidv4' | 'test')\n * @param sorted - when true, `uuid()` will prefer sortable SUIDs\n */\nexport function setUuidDefaultEncoding(mode?: keyof typeof mapModes, sorted = false) {\n  if (mode === 'test')\n    unameReset('test')\n\n  _mode = mode ?? 'base62'\n  _sorted = sorted\n}\n\n/**\n * Generate an identifier using the current encoding mode.\n *\n * If the default encoding is configured with `sorted=true`, this returns a\n * sortable SUID; otherwise a random UUID is returned.\n *\n * @returns encoded identifier string\n */\nexport function uuid(): string {\n  return mapModes[_mode].uuid(_sorted ? suidBytes() : uuidBytes())\n}\n\n/**\n * Decode an encoded identifier according to the current encoding mode into\n * raw bytes.\n *\n * @param uuid - encoded identifier string\n * @returns raw 16-byte Uint8Array\n */\nexport function uuidDecode(uuid: string): Uint8Array {\n  return mapModes[_mode].uuidDecode(uuid)\n}\n\n/**\n * Encode raw UUID bytes using the current encoding mode.\n *\n * @param bytes - 16-byte Uint8Array\n * @returns encoded identifier string\n */\nexport function uuidEncode(bytes: Uint8Array): string {\n  return mapModes[_mode].uuidEncode(bytes)\n}\n\n/**\n * Validate an encoded identifier by attempting to decode it and checking\n * for the expected byte length.\n *\n * @param uuid - encoded identifier string\n * @returns true when valid and decodes to 16 bytes\n */\nexport function uuidIsValid(uuid: string): boolean {\n  try {\n    const bin = uuidDecode(uuid)\n    return bin.length === uuidBytesLength\n  }\n  catch (err) {\n    // log.warn('Invalid ID:', uuid)\n  }\n  return false\n}\n\n// Simple Counters\n\nconst _unameCounters: Record<string, number> = {}\n\n/**\n * Simple counter-based unique name generator.\n *\n * Returns strings like 'name-0', 'name-1', ... and increments an internal\n * counter per `name`.\n *\n * @param name - base name for the counter (default: 'id')\n * @returns generated unique name\n */\nexport function uname(name = 'id'): string {\n  if (_unameCounters[name] == null)\n    _unameCounters[name] = 0\n\n  return `${name}-${_unameCounters[name]++}`\n}\n\n/** Reset the counter used by `uname` for the given name. */\nexport function unameReset(name = 'id') {\n  _unameCounters[name] = 0\n}\n\nlet _qid = 0\n\n/**\n * Quick global incremental id generator.\n *\n * Returns strings like 'id-0', 'id-1', ... using a single global counter.\n */\nexport function qid(): string {\n  return `id-${_qid++}`\n}\n"]}

package/dist/chunk-G2YLVA2Z.js

@@ -1,2 +0,0 @@
-import{a as p}from"./chunk-5NKC2EQJ.js";function h(i,a,c={cyclesFix:!0},f=[]){let r=[],u=Array.isArray(i);for(let e in i){let t=i[e],s=u?+e:e;if(!(e in a)){r.push({type:"del",path:[s]});continue}let n=a[e],y=typeof t=="object"&&typeof n=="object";if(t&&n&&y&&!["Date","RegExp","String","Number"].includes(Object.getPrototypeOf(t).constructor.name)&&(!c.cyclesFix||!f.includes(t))){let d=h(t,n,c,c.cyclesFix?f.concat([t]):[]);r=[...r,...d.map(o=>(o.path.unshift(s),o))]}else t!==n&&!(y&&(Number.isNaN(t)?`${t}`==`${n}`:+t==+n))&&r.push({path:[s],type:"upd",value:n})}let l=Array.isArray(a);for(let e in a)e in i||r.push({type:"new",path:[l?+e:e],value:a[e]});return r}p(h,"diffObjects");export{h as a};
-//# sourceMappingURL=chunk-G2YLVA2Z.js.map

package/dist/chunk-G2YLVA2Z.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/data/diff.ts"],"sourcesContent":["// Original from https://github.com/AsyncBanana/microdiff MIT\n// Alternative https://github.com/kpdecker/jsdiff\n\nexport type DifferenceType = 'new' | 'upd' | 'del'\n\nexport interface Difference {\n  type: DifferenceType\n  path: (string | number)[]\n  value?: any\n}\n\nexport interface DiffOptions {\n  cyclesFix: boolean\n}\n\n/**\n * Describes the changes between to object with a list like:\n *\n * ```\n * [{\n *    type: 'upd',\n *    path: ['a'],\n *    value: 1\n * },\n * {\n *    type: 'del',\n *    path: ['b', 'c']\n * }\n * ...]\n * ```\n */\nexport function diffObjects(\n  obj: Record<string, any> | any[],\n  newObj: Record<string, any> | any[],\n  options: Partial<DiffOptions> = { cyclesFix: true },\n  _stack: Record<string, any>[] = [],\n): Difference[] {\n  let diffs: Difference[] = []\n  const isObjArray = Array.isArray(obj)\n\n  for (const key in obj) {\n    const objValue = (obj as any)[key] // works for both array and record, only TS doesn't know ;)\n    const path = isObjArray ? +key : key\n    if (!(key in newObj)) {\n      diffs.push({\n        type: 'del',\n        path: [path],\n      })\n      continue\n    }\n    const newValue = (newObj as any)[key]\n    const areObjects = typeof objValue === 'object' && typeof newValue === 'object'\n    if (objValue\n      && newValue\n      && areObjects\n      && !(['Date', 'RegExp', 'String', 'Number'].includes(Object.getPrototypeOf(objValue).constructor.name))\n      && (options.cyclesFix ? !_stack.includes(objValue) : true)\n    ) {\n      const nestedDiffs = diffObjects(\n        objValue,\n        newValue,\n        options,\n        options.cyclesFix ? _stack.concat([objValue]) : [],\n      )\n      diffs = [...diffs, ...nestedDiffs.map((difference) => {\n        difference.path.unshift(path)\n        return difference\n      })]\n    }\n    else if (\n      objValue !== newValue\n      && !(\n        areObjects\n        && (Number.isNaN(objValue)\n          ? `${objValue}` === `${newValue}`\n          : +objValue === +newValue)\n      )\n    ) {\n      diffs.push({\n        path: [path],\n        type: 'upd',\n        value: newValue,\n      })\n    }\n  }\n\n  const isNewObjArray = Array.isArray(newObj)\n  for (const key in newObj) {\n    if (!(key in obj)) {\n      diffs.push({\n        type: 'new',\n        path: [isNewObjArray ? +key : key],\n        value: (newObj as any)[key], // works for both array and record, only TS doesn't know ;)\n      })\n    }\n  }\n  return diffs\n}\n"],"mappings":"wCA+BO,SAASA,EACdC,EACAC,EACAC,EAAgC,CAAE,UAAW,EAAK,EAClDC,EAAgC,CAAC,EACnB,CACd,IAAIC,EAAsB,CAAC,EACrBC,EAAa,MAAM,QAAQL,CAAG,EAEpC,QAAWM,KAAON,EAAK,CACrB,IAAMO,EAAYP,EAAYM,CAAG,EAC3BE,EAAOH,EAAa,CAACC,EAAMA,EACjC,GAAI,EAAEA,KAAOL,GAAS,CACpBG,EAAM,KAAK,CACT,KAAM,MACN,KAAM,CAACI,CAAI,CACb,CAAC,EACD,QACF,CACA,IAAMC,EAAYR,EAAeK,CAAG,EAC9BI,EAAa,OAAOH,GAAa,UAAY,OAAOE,GAAa,SACvE,GAAIF,GACCE,GACAC,GACA,CAAE,CAAC,OAAQ,SAAU,SAAU,QAAQ,EAAE,SAAS,OAAO,eAAeH,CAAQ,EAAE,YAAY,IAAI,IACjG,CAAAL,EAAQ,WAAY,CAACC,EAAO,SAASI,CAAQ,GACjD,CACA,IAAMI,EAAcZ,EAClBQ,EACAE,EACAP,EACAA,EAAQ,UAAYC,EAAO,OAAO,CAACI,CAAQ,CAAC,EAAI,CAAC,CACnD,EACAH,EAAQ,CAAC,GAAGA,EAAO,GAAGO,EAAY,IAAKC,IACrCA,EAAW,KAAK,QAAQJ,CAAI,EACrBI,EACR,CAAC,CACJ,MAEEL,IAAaE,GACV,EACDC,IACI,OAAO,MAAMH,CAAQ,EACrB,GAAGA,CAAQ,IAAO,GAAGE,CAAQ,GAC7B,CAACF,GAAa,CAACE,KAGrBL,EAAM,KAAK,CACT,KAAM,CAACI,CAAI,EACX,KAAM,MACN,MAAOC,CACT,CAAC,CAEL,CAEA,IAAMI,EAAgB,MAAM,QAAQZ,CAAM,EAC1C,QAAWK,KAAOL,EACVK,KAAON,GACXI,EAAM,KAAK,CACT,KAAM,MACN,KAAM,CAACS,EAAgB,CAACP,EAAMA,CAAG,EACjC,MAAQL,EAAeK,CAAG,CAC5B,CAAC,EAGL,OAAOF,CACT,CAlEgBU,EAAAf,EAAA","names":["diffObjects","obj","newObj","options","_stack","diffs","isObjArray","key","objValue","path","newValue","areObjects","nestedDiffs","difference","isNewObjArray","__name"]}

package/dist/chunk-G6Z2U3BO.js

@@ -1,2 +0,0 @@
-import{b as u}from"./chunk-XFJ4RS6Z.js";import{a as c}from"./chunk-UWM7RELA.js";import{c as a}from"./chunk-R3IUCVWM.js";import{u as h}from"./chunk-KDKT5HPM.js";import{a as i}from"./chunk-5NKC2EQJ.js";var r=class extends c{static{i(this,"PubSub")}name;channel;encoder;log;debug;get shortId(){return this.name.substr(0,6)}constructor(e){super();let{name:n,encoder:t=new u,channel:l,debug:m=!1}=e;this.channel=l,this.encoder=t,this.debug=m,this.name=n??this.channel.id??h("pubsub"),this.log=a(`${this.shortId}`),this.debug&&(this.channel.on("connect",()=>{this.log("channel connected")}),this.channel.on("disconnect",()=>{this.log("channel disconnected")})),this.channel.on("message",async({data:d})=>{let s=await this.encoder.decode(d);if(this.debug?this.log(`channel message, event=${s?.event}, info=`,s):this.log(`channel message, event=${s?.event}`),s){let{event:g,args:b}=s;await this.emitSuper(g,...b)}})}async emitSuper(e,...n){return await super.emit(e,...n)}async emit(e,...n){try{if(this.debug?this.log(`emit(${String(e)})`,e):this.log(`emit(${String(e)})`,n.length),!this.channel.isConnected)return this.log.warn("channel not connected"),!1;let t=await this.encoder.encode({event:e,args:n});return this.channel.postMessage(t),!0}catch(t){this.log.warn(`emit(${String(e)})`,t)}return!1}async publish(e,...n){return await this.emit(e,...n)}subscribe(e,n,t={}){return this.on(e,n,t)}};function S(o){return new r(o)}i(S,"usePubSub");export{r as a,S as b};
-//# sourceMappingURL=chunk-G6Z2U3BO.js.map

package/dist/chunk-G6Z2U3BO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/msg/pubsub.ts"],"sourcesContent":["import type { DisposerFunction } from '../dispose-types'\nimport type { Channel } from './channel'\nimport type { DefaultListener, EmitterSubscriberOptions, ListenerSignature } from './emitter'\nimport type { Encoder } from './encoder'\nimport { DefaultLogger } from '../log/log'\nimport { uname } from '../uuid'\nimport { Emitter } from './emitter'\nimport { JsonEncoder } from './encoder'\n\nexport interface PubSubConfig {\n  channel: Channel\n  encoder?: Encoder\n  name?: string\n  debug?: boolean\n}\n\nexport class PubSub<L extends ListenerSignature<L> = DefaultListener> extends Emitter<L> {\n  name: string\n  channel: Channel\n  encoder: Encoder\n  log: any\n  debug: boolean\n\n  get shortId() {\n    return this.name.substr(0, 6)\n  }\n\n  constructor(opt: PubSubConfig) {\n    super()\n\n    const { name, encoder = new JsonEncoder(), channel, debug = false } = opt\n\n    this.channel = channel\n    this.encoder = encoder\n    this.debug = debug\n\n    this.name = name ?? this.channel.id ?? uname('pubsub')\n    this.log = DefaultLogger(`${this.shortId}`)\n\n    if (this.debug) {\n      this.channel.on('connect', () => {\n        this.log('channel connected')\n      })\n      this.channel.on('disconnect', () => {\n        this.log('channel disconnected')\n      })\n    }\n\n    this.channel.on('message', async ({ data }) => {\n      const info = await this.encoder.decode(data)\n      if (this.debug)\n        this.log(`channel message, event=${info?.event}, info=`, info)\n      else this.log(`channel message, event=${info?.event}`)\n      if (info) {\n        const { event, args } = info\n        await this.emitSuper(event, ...args)\n      }\n    })\n  }\n\n  private async emitSuper<U extends keyof L>(\n    event: U,\n    ...args: Parameters<L[U]>\n  ): Promise<boolean> {\n    return await super.emit(event, ...args)\n  }\n\n  async emit<U extends keyof L>(\n    event: U,\n    ...args: Parameters<L[U]>\n  ): Promise<boolean> {\n    try {\n      if (this.debug)\n        this.log(`emit(${String(event)})`, event)\n      else this.log(`emit(${String(event)})`, args.length)\n      if (!this.channel.isConnected) {\n        this.log.warn('channel not connected')\n        return false\n      }\n      const data = await this.encoder.encode({ event, args })\n      this.channel.postMessage(data)\n      return true\n    }\n    catch (err) {\n      this.log.warn(`emit(${String(event)})`, err)\n    }\n    return false\n  }\n\n  public async publish<U extends keyof L>(\n    event: U,\n    ...args: Parameters<L[U]>\n  ): Promise<boolean> {\n    return await this.emit(event, ...args)\n  }\n\n  public subscribe<U extends keyof L>(\n    event: U,\n    fn: L[U],\n    opt: EmitterSubscriberOptions = {},\n  ): DisposerFunction {\n    return this.on(event as any as string | number, fn as any, opt)\n  }\n}\n\nexport function usePubSub<L extends ListenerSignature<L> = DefaultListener>(\n  opt: PubSubConfig,\n) {\n  return new PubSub<L>(opt)\n}\n"],"mappings":"wMAgBO,IAAMA,EAAN,cAAuEC,CAAW,CAhBzF,MAgByF,CAAAC,EAAA,eACvF,KACA,QACA,QACA,IACA,MAEA,IAAI,SAAU,CACZ,OAAO,KAAK,KAAK,OAAO,EAAG,CAAC,CAC9B,CAEA,YAAYC,EAAmB,CAC7B,MAAM,EAEN,GAAM,CAAE,KAAAC,EAAM,QAAAC,EAAU,IAAIC,EAAe,QAAAC,EAAS,MAAAC,EAAQ,EAAM,EAAIL,EAEtE,KAAK,QAAUI,EACf,KAAK,QAAUF,EACf,KAAK,MAAQG,EAEb,KAAK,KAAOJ,GAAQ,KAAK,QAAQ,IAAMK,EAAM,QAAQ,EACrD,KAAK,IAAMC,EAAc,GAAG,KAAK,OAAO,EAAE,EAEtC,KAAK,QACP,KAAK,QAAQ,GAAG,UAAW,IAAM,CAC/B,KAAK,IAAI,mBAAmB,CAC9B,CAAC,EACD,KAAK,QAAQ,GAAG,aAAc,IAAM,CAClC,KAAK,IAAI,sBAAsB,CACjC,CAAC,GAGH,KAAK,QAAQ,GAAG,UAAW,MAAO,CAAE,KAAAC,CAAK,IAAM,CAC7C,IAAMC,EAAO,MAAM,KAAK,QAAQ,OAAOD,CAAI,EAI3C,GAHI,KAAK,MACP,KAAK,IAAI,0BAA0BC,GAAM,KAAK,UAAWA,CAAI,EAC1D,KAAK,IAAI,0BAA0BA,GAAM,KAAK,EAAE,EACjDA,EAAM,CACR,GAAM,CAAE,MAAAC,EAAO,KAAAC,CAAK,EAAIF,EACxB,MAAM,KAAK,UAAUC,EAAO,GAAGC,CAAI,CACrC,CACF,CAAC,CACH,CAEA,MAAc,UACZD,KACGC,EACe,CAClB,OAAO,MAAM,MAAM,KAAKD,EAAO,GAAGC,CAAI,CACxC,CAEA,MAAM,KACJD,KACGC,EACe,CAClB,GAAI,CAIF,GAHI,KAAK,MACP,KAAK,IAAI,QAAQ,OAAOD,CAAK,CAAC,IAAKA,CAAK,EACrC,KAAK,IAAI,QAAQ,OAAOA,CAAK,CAAC,IAAKC,EAAK,MAAM,EAC/C,CAAC,KAAK,QAAQ,YAChB,YAAK,IAAI,KAAK,uBAAuB,EAC9B,GAET,IAAMH,EAAO,MAAM,KAAK,QAAQ,OAAO,CAAE,MAAAE,EAAO,KAAAC,CAAK,CAAC,EACtD,YAAK,QAAQ,YAAYH,CAAI,EACtB,EACT,OACOI,EAAK,CACV,KAAK,IAAI,KAAK,QAAQ,OAAOF,CAAK,CAAC,IAAKE,CAAG,CAC7C,CACA,MAAO,EACT,CAEA,MAAa,QACXF,KACGC,EACe,CAClB,OAAO,MAAM,KAAK,KAAKD,EAAO,GAAGC,CAAI,CACvC,CAEO,UACLD,EACAG,EACAb,EAAgC,CAAC,EACf,CAClB,OAAO,KAAK,GAAGU,EAAiCG,EAAWb,CAAG,CAChE,CACF,EAEO,SAASc,EACdd,EACA,CACA,OAAO,IAAIH,EAAUG,CAAG,CAC1B,CAJgBD,EAAAe,EAAA","names":["PubSub","Emitter","__name","opt","name","encoder","JsonEncoder","channel","debug","uname","DefaultLogger","data","info","event","args","err","fn","usePubSub"]}

package/dist/chunk-GAJVPW4Z.js

@@ -1,2 +0,0 @@
-import{a as n}from"./chunk-5NKC2EQJ.js";function t(e){return e._object!=null}n(t,"isSchemaObject");function a(e){return e._optional===!0}n(a,"isSchemaOptional");function r(e){return e._default!=null}n(r,"isSchemaDefault");function o(e){return!t(e)}n(o,"isSchemaPrimitive");function i(e){return t(e)&&Object.values(e._object).every(o)}n(i,"isSchemaObjectFlat");export{t as a,a as b,r as c,o as d,i as e};
-//# sourceMappingURL=chunk-GAJVPW4Z.js.map

package/dist/chunk-GAJVPW4Z.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/schema/utils.ts"],"sourcesContent":["import type { Type } from './schema'\n\nexport function isSchemaObject(schema: Type<any>): boolean {\n  return schema._object != null\n}\n\nexport function isSchemaOptional(schema: Type<any>): boolean {\n  return schema._optional === true\n}\n\nexport function isSchemaDefault(schema: Type<any>): boolean {\n  return schema._default != null\n}\n\nexport function isSchemaPrimitive(schema: Type<any>): boolean {\n  return !isSchemaObject(schema) // todo\n}\n\nexport function isSchemaObjectFlat(schema: Type<any>): boolean {\n  return isSchemaObject(schema) && Object.values(schema._object!).every(isSchemaPrimitive as any) // todo\n}\n"],"mappings":"wCAEO,SAASA,EAAeC,EAA4B,CACzD,OAAOA,EAAO,SAAW,IAC3B,CAFgBC,EAAAF,EAAA,kBAIT,SAASG,EAAiBF,EAA4B,CAC3D,OAAOA,EAAO,YAAc,EAC9B,CAFgBC,EAAAC,EAAA,oBAIT,SAASC,EAAgBH,EAA4B,CAC1D,OAAOA,EAAO,UAAY,IAC5B,CAFgBC,EAAAE,EAAA,mBAIT,SAASC,EAAkBJ,EAA4B,CAC5D,MAAO,CAACD,EAAeC,CAAM,CAC/B,CAFgBC,EAAAG,EAAA,qBAIT,SAASC,EAAmBL,EAA4B,CAC7D,OAAOD,EAAeC,CAAM,GAAK,OAAO,OAAOA,EAAO,OAAQ,EAAE,MAAMI,CAAwB,CAChG,CAFgBH,EAAAI,EAAA","names":["isSchemaObject","schema","__name","isSchemaOptional","isSchemaDefault","isSchemaPrimitive","isSchemaObjectFlat"]}

package/dist/chunk-GAOCL7A2.js

@@ -1,2 +0,0 @@
-import{a as e}from"./chunk-5NKC2EQJ.js";var n=/[\\\-[\]/{}()*+?.^$|]/g;function t(r){return r?r instanceof RegExp?r.source:r.replace(n,"\\$&"):""}e(t,"escapeRegExp");export{t as a};
-//# sourceMappingURL=chunk-GAOCL7A2.js.map

package/dist/chunk-GAOCL7A2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/data/regexp.ts"],"sourcesContent":["const rxEscape = /[\\\\\\-[\\]/{}()*+?.^$|]/g // Finds: \\ - [ ] / { } ( ) * + ? . ^ $ |\n\nexport function escapeRegExp(value: RegExp | string): string {\n  if (!value)\n    return ''\n  if (value instanceof RegExp)\n    return value.source\n  return value.replace(rxEscape, '\\\\$&')\n}\n"],"mappings":"wCAAA,IAAMA,EAAW,yBAEV,SAASC,EAAaC,EAAgC,CAC3D,OAAKA,EAEDA,aAAiB,OACZA,EAAM,OACRA,EAAM,QAAQF,EAAU,MAAM,EAH5B,EAIX,CANgBG,EAAAF,EAAA","names":["rxEscape","escapeRegExp","value","__name"]}

package/dist/chunk-GARQAHQE.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkLONV4KUScjs = require('./chunk-LONV4KUS.cjs');var _chunkFMMEBQFRcjs = require('./chunk-FMMEBQFR.cjs');var _chunkZEDMMWJIcjs = require('./chunk-ZEDMMWJI.cjs');var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');function f(){_chunkFMMEBQFRcjs.p.call(void 0, "test"),_chunkZEDMMWJIcjs.a.call(void 0, ),_chunkLONV4KUScjs.a.call(void 0, )}_chunkP7XCQ7WVcjs.a.call(void 0, f,"setTestMode");exports.a = f;
-//# sourceMappingURL=chunk-GARQAHQE.cjs.map

package/dist/chunk-GARQAHQE.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-GARQAHQE.cjs","../src/common/test.ts"],"names":["setTestMode","setUuidDefaultEncoding","setTimestampTest","setDayTest","__name"],"mappings":"AAAA,iIAAwC,wDAAyC,wDAAyC,wDAAyC,SCInJA,CAAAA,CAAAA,CAAc,CAC5BC,iCAAAA,MAA6B,CAAA,CAC7BC,iCAAAA,CAAiB,CACjBC,iCAAAA,CACF,CAJgBC,iCAAAA,CAAAJ,CAAA,aAAA,CAAA,CAAA,cAAA","file":"/Users/dirk/work/github-zeed/dist/chunk-GARQAHQE.cjs","sourcesContent":[null,"import { setDayTest } from './data'\nimport { setTimestampTest } from './time'\nimport { setUuidDefaultEncoding } from './uuid'\n\nexport function setTestMode() {\n  setUuidDefaultEncoding('test')\n  setTimestampTest()\n  setDayTest()\n}\n"]}

package/dist/chunk-GAW2WNI3.js

@@ -1,2 +0,0 @@
-import{b as d}from"./chunk-JSX6JZHU.js";import{i as p}from"./chunk-6EQDC7VW.js";import{a as s}from"./chunk-5NKC2EQJ.js";var c=s(()=>{let n=s(()=>{},"dispose");return n[Symbol.dispose]=n,n},"noopDisposer");function l(n,i=0){let o=setTimeout(n,i),e=s(()=>{o&&(clearTimeout(o),o=void 0)},"dispose");return e[Symbol.dispose]=e,e}s(l,"useTimeout");function a(n,i){let o=setInterval(n,i),e=s(()=>{o&&(clearInterval(o),o=void 0)},"dispose");return e[Symbol.dispose]=e,e}s(a,"useInterval");function y(n,i,o=!1){let e,t=!1;async function r(f=!1){f&&await p(n()),t||(e=setTimeout(()=>r(!0),i))}s(r,"loop"),r(o);let u=s(()=>{e&&(t=!0,clearInterval(e),e=void 0)},"dispose");return u[Symbol.dispose]=u,u}s(y,"useIntervalPause");function v(n,i,o,...e){if(n==null)return c();n.on?n.on(i,o,...e):n.addEventListener&&n.addEventListener(i,o,...e);let t=s(()=>{n.off?n.off(i,o,...e):n.removeEventListener&&n.removeEventListener(i,o,...e)},"dispose");return t[Symbol.dispose]=t,t}s(v,"useEventListener");function E(n,i,o,...e){if(n==null)return c();n.on?n.once(i,o,...e):n.addEventListener&&n.addEventListener(i,o,...e);let t=s(()=>{n.off?n.off(i,o,...e):n.removeEventListener&&n.removeEventListener(i,o,...e)},"dispose");return t[Symbol.dispose]=t,t}s(E,"useEventListenerOnce");function D(n){let i=d(n);return Object.assign(i,{timeout:s((o,e=0)=>i.add(l(o,e)),"timeout"),interval:s((o,e=0)=>i.add(a(o,e)),"interval"),intervalPause:s((o,e=0)=>i.add(y(o,e)),"intervalPause"),on:s((o,e,t,...r)=>i.add(v(o,e,t,...r)),"on"),once:s((o,e,t,...r)=>i.add(E(o,e,t,...r)),"once")})}s(D,"useDisposeWithUtils");export{c as a,l as b,a as c,y as d,v as e,E as f,D as g};
-//# sourceMappingURL=chunk-GAW2WNI3.js.map

package/dist/chunk-GAW2WNI3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/dispose-utils.ts"],"sourcesContent":["import type { UseDisposeConfig } from './dispose-defer'\nimport type { DisposerFunction } from './dispose-types'\nimport type { LoggerInterface } from './log/log-base'\nimport { useDispose } from './dispose-defer'\nimport { promisify } from './exec/promise'\n\nexport type TimerExecFunction = () => void | Promise<void>\n\nexport const noopDisposer: () => DisposerFunction = () => {\n  const dispose = () => {}\n  dispose[Symbol.dispose] = dispose\n  return dispose\n}\n\n/**\n * Executes a function after a specified timeout and returns a disposer function\n * that can be used to cancel the timeout.\n *\n * @param fn - The function to execute after the timeout.\n * @param timeout - The timeout duration in milliseconds (default: 0).\n * @returns A disposer function that can be used to cancel the timeout.\n */\nexport function useTimeout(fn: TimerExecFunction, timeout = 0): DisposerFunction {\n  let timeoutHandle: any = setTimeout(fn, timeout)\n  const dispose = () => {\n    if (timeoutHandle) {\n      clearTimeout(timeoutHandle)\n      timeoutHandle = undefined\n    }\n  }\n  dispose[Symbol.dispose] = dispose\n  return dispose\n}\n\n/**\n * Executes a function repeatedly at a specified interval and returns a disposer function\n * that can be used to stop the execution.\n *\n * @param fn - The function to be executed at the specified interval.\n * @param interval - The interval (in milliseconds) at which the function should be executed.\n * @returns A disposer function that can be used to stop the execution of the function.\n */\nexport function useInterval(fn: TimerExecFunction, interval: number): DisposerFunction {\n  let intervalHandle: any = setInterval(fn, interval)\n  const dispose = () => {\n    if (intervalHandle) {\n      clearInterval(intervalHandle)\n      intervalHandle = undefined\n    }\n  }\n  dispose[Symbol.dispose] = dispose\n  return dispose\n}\n\n/** The interval starts only, when the function is finished. */\nexport function useIntervalPause(fn: TimerExecFunction, interval: number, immediately = false): DisposerFunction {\n  let intervalHandle: any\n  let stop = false\n\n  async function loop(exec = false) {\n    if (exec)\n      await promisify(fn())\n    if (!stop)\n      intervalHandle = setTimeout(() => loop(true), interval)\n  }\n\n  void loop(immediately)\n\n  const dispose = () => {\n    if (intervalHandle) {\n      stop = true\n      clearInterval(intervalHandle)\n      intervalHandle = undefined\n    }\n  }\n  dispose[Symbol.dispose] = dispose\n  return dispose\n}\n\nexport function useEventListener(\n  emitter: any,\n  eventName: string,\n  fn: (ev?: any) => void,\n  ...args: any[]\n): DisposerFunction {\n  if (emitter == null)\n    return noopDisposer()\n  if (emitter.on)\n    emitter.on(eventName, fn, ...args)\n  else if (emitter.addEventListener)\n    emitter.addEventListener(eventName, fn, ...args)\n  const dispose = () => {\n    if (emitter.off)\n      emitter.off(eventName, fn, ...args)\n    else if (emitter.removeEventListener)\n      emitter.removeEventListener(eventName, fn, ...args)\n  }\n  dispose[Symbol.dispose] = dispose\n  return dispose\n}\n\nexport function useEventListenerOnce(\n  emitter: any,\n  eventName: string,\n  fn: (ev?: any) => void,\n  ...args: any[]\n): DisposerFunction {\n  if (emitter == null)\n    return noopDisposer()\n  if (emitter.on)\n    emitter.once(eventName, fn, ...args)\n  else if (emitter.addEventListener)\n    emitter.addEventListener(eventName, fn, ...args)\n  const dispose = () => {\n    if (emitter.off)\n      emitter.off(eventName, fn, ...args)\n    else if (emitter.removeEventListener)\n      emitter.removeEventListener(eventName, fn, ...args)\n  }\n  dispose[Symbol.dispose] = dispose\n  return dispose\n}\n\n/** Like useDispose but with shorthands for emitter and timers */\nexport function useDisposeWithUtils(config?: string | UseDisposeConfig | LoggerInterface) {\n  const dispose = useDispose(config)\n  return Object.assign(dispose, {\n    timeout: (fn: TimerExecFunction, timeout = 0) => dispose.add(useTimeout(fn, timeout))!,\n    interval: (fn: TimerExecFunction, interval = 0) => dispose.add(useInterval(fn, interval))!,\n    intervalPause: (fn: TimerExecFunction, interval = 0) => dispose.add(useIntervalPause(fn, interval))!,\n    on: (emitter: any, eventName: string, fn: (ev?: any) => void, ...args: any[]) => dispose.add(useEventListener(emitter, eventName, fn, ...args))!,\n    once: (emitter: any, eventName: string, fn: (ev?: any) => void, ...args: any[]) => dispose.add(useEventListenerOnce(emitter, eventName, fn, ...args))!,\n  })\n}\n\nexport type UseDisposeWithUtils = ReturnType<typeof useDisposeWithUtils>\n"],"mappings":"wHAQO,IAAMA,EAAuCC,EAAA,IAAM,CACxD,IAAMC,EAAUD,EAAA,IAAM,CAAC,EAAP,WAChB,OAAAC,EAAQ,OAAO,OAAO,EAAIA,EACnBA,CACT,EAJoD,gBAc7C,SAASC,EAAWC,EAAuBC,EAAU,EAAqB,CAC/E,IAAIC,EAAqB,WAAWF,EAAIC,CAAO,EACzCH,EAAUD,EAAA,IAAM,CAChBK,IACF,aAAaA,CAAa,EAC1BA,EAAgB,OAEpB,EALgB,WAMhB,OAAAJ,EAAQ,OAAO,OAAO,EAAIA,EACnBA,CACT,CAVgBD,EAAAE,EAAA,cAoBT,SAASI,EAAYH,EAAuBI,EAAoC,CACrF,IAAIC,EAAsB,YAAYL,EAAII,CAAQ,EAC5CN,EAAUD,EAAA,IAAM,CAChBQ,IACF,cAAcA,CAAc,EAC5BA,EAAiB,OAErB,EALgB,WAMhB,OAAAP,EAAQ,OAAO,OAAO,EAAIA,EACnBA,CACT,CAVgBD,EAAAM,EAAA,eAaT,SAASG,EAAiBN,EAAuBI,EAAkBG,EAAc,GAAyB,CAC/G,IAAIF,EACAG,EAAO,GAEX,eAAeC,EAAKC,EAAO,GAAO,CAC5BA,GACF,MAAMC,EAAUX,EAAG,CAAC,EACjBQ,IACHH,EAAiB,WAAW,IAAMI,EAAK,EAAI,EAAGL,CAAQ,EAC1D,CALeP,EAAAY,EAAA,QAOVA,EAAKF,CAAW,EAErB,IAAMT,EAAUD,EAAA,IAAM,CAChBQ,IACFG,EAAO,GACP,cAAcH,CAAc,EAC5BA,EAAiB,OAErB,EANgB,WAOhB,OAAAP,EAAQ,OAAO,OAAO,EAAIA,EACnBA,CACT,CAtBgBD,EAAAS,EAAA,oBAwBT,SAASM,EACdC,EACAC,EACAd,KACGe,EACe,CAClB,GAAIF,GAAW,KACb,OAAOjB,EAAa,EAClBiB,EAAQ,GACVA,EAAQ,GAAGC,EAAWd,EAAI,GAAGe,CAAI,EAC1BF,EAAQ,kBACfA,EAAQ,iBAAiBC,EAAWd,EAAI,GAAGe,CAAI,EACjD,IAAMjB,EAAUD,EAAA,IAAM,CAChBgB,EAAQ,IACVA,EAAQ,IAAIC,EAAWd,EAAI,GAAGe,CAAI,EAC3BF,EAAQ,qBACfA,EAAQ,oBAAoBC,EAAWd,EAAI,GAAGe,CAAI,CACtD,EALgB,WAMhB,OAAAjB,EAAQ,OAAO,OAAO,EAAIA,EACnBA,CACT,CApBgBD,EAAAe,EAAA,oBAsBT,SAASI,EACdH,EACAC,EACAd,KACGe,EACe,CAClB,GAAIF,GAAW,KACb,OAAOjB,EAAa,EAClBiB,EAAQ,GACVA,EAAQ,KAAKC,EAAWd,EAAI,GAAGe,CAAI,EAC5BF,EAAQ,kBACfA,EAAQ,iBAAiBC,EAAWd,EAAI,GAAGe,CAAI,EACjD,IAAMjB,EAAUD,EAAA,IAAM,CAChBgB,EAAQ,IACVA,EAAQ,IAAIC,EAAWd,EAAI,GAAGe,CAAI,EAC3BF,EAAQ,qBACfA,EAAQ,oBAAoBC,EAAWd,EAAI,GAAGe,CAAI,CACtD,EALgB,WAMhB,OAAAjB,EAAQ,OAAO,OAAO,EAAIA,EACnBA,CACT,CApBgBD,EAAAmB,EAAA,wBAuBT,SAASC,EAAoBC,EAAsD,CACxF,IAAMpB,EAAUqB,EAAWD,CAAM,EACjC,OAAO,OAAO,OAAOpB,EAAS,CAC5B,QAASD,EAAA,CAACG,EAAuBC,EAAU,IAAMH,EAAQ,IAAIC,EAAWC,EAAIC,CAAO,CAAC,EAA3E,WACT,SAAUJ,EAAA,CAACG,EAAuBI,EAAW,IAAMN,EAAQ,IAAIK,EAAYH,EAAII,CAAQ,CAAC,EAA9E,YACV,cAAeP,EAAA,CAACG,EAAuBI,EAAW,IAAMN,EAAQ,IAAIQ,EAAiBN,EAAII,CAAQ,CAAC,EAAnF,iBACf,GAAIP,EAAA,CAACgB,EAAcC,EAAmBd,KAA2Be,IAAgBjB,EAAQ,IAAIc,EAAiBC,EAASC,EAAWd,EAAI,GAAGe,CAAI,CAAC,EAA1I,MACJ,KAAMlB,EAAA,CAACgB,EAAcC,EAAmBd,KAA2Be,IAAgBjB,EAAQ,IAAIkB,EAAqBH,EAASC,EAAWd,EAAI,GAAGe,CAAI,CAAC,EAA9I,OACR,CAAC,CACH,CATgBlB,EAAAoB,EAAA","names":["noopDisposer","__name","dispose","useTimeout","fn","timeout","timeoutHandle","useInterval","interval","intervalHandle","useIntervalPause","immediately","stop","loop","exec","promisify","useEventListener","emitter","eventName","args","useEventListenerOnce","useDisposeWithUtils","config","useDispose"]}

package/dist/chunk-GFMSFYKE.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkIVUEQANCcjs = require('./chunk-IVUEQANC.cjs');var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');function f(r,e,t,n){return e===!0?r(t,n):_chunkIVUEQANCcjs.h.call(void 0, e)&&e.length>0?r(e,n):_chunkIVUEQANCcjs.i.call(void 0, e)?r(t,e):typeof e=="function"?e:r(t,!1)}_chunkP7XCQ7WVcjs.a.call(void 0, f,"_LoggerFromConfig");exports.a = f;
-//# sourceMappingURL=chunk-GFMSFYKE.cjs.map

package/dist/chunk-GFMSFYKE.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-GFMSFYKE.cjs","../src/common/log/log-config.ts"],"names":["_LoggerFromConfig","Logger","config","name","level","isString","isNumber","__name"],"mappings":"AAAA,iIAA+C,wDAAyC,SCkBxEA,CAAAA,CACdC,CAAAA,CACAC,CAAAA,CACAC,CAAAA,CACAC,CAAAA,CACiB,CACjB,OAAIF,CAAAA,GAAW,CAAA,CAAA,CACND,CAAAA,CAAOE,CAAAA,CAAMC,CAAK,CAAA,CACvBC,iCAAAA,CAAe,CAAA,EAAKH,CAAAA,CAAO,MAAA,CAAS,CAAA,CAC/BD,CAAAA,CAAOC,CAAAA,CAAQE,CAAK,CAAA,CACzBE,iCAAAA,CAAe,CAAA,CACVL,CAAAA,CAAOE,CAAAA,CAAMD,CAAM,CAAA,CACxB,OAAOA,CAAAA,EAAW,UAAA,CACbA,CAAAA,CACFD,CAAAA,CAAOE,CAAAA,CAAM,CAAA,CAAK,CAC3B,CAfgBI,iCAAAA,CAAAP,CAAA,mBAAA,CAAA,CAAA,cAAA","file":"/Users/dirk/work/github-zeed/dist/chunk-GFMSFYKE.cjs","sourcesContent":[null,"import type { LoggerInterface, LogLevelAliasType } from './log-base'\nimport { isNumber, isString } from '../data/is'\n\n/**\n * Simple log configuration for use in modular scenarios.\n *\n * `LogConfig` can be of various types:\n *\n * 1. `LoggerInterface`: Just a complete logger howeveryou like it\n * 2. `true`: The default logger on\n * 3. `string`: Logger with name\n * 4. `number`: Logger with level e.g. set to `0` to see all\n *\n * All others turn it off.\n */\nexport type LogConfig = LoggerInterface | string | number | null | undefined | boolean\n\n/** See LogConfig */\nexport function _LoggerFromConfig(\n  Logger: (name?: string, level?: LogLevelAliasType) => LoggerInterface,\n  config: LogConfig,\n  name: string,\n  level?: LogLevelAliasType,\n): LoggerInterface {\n  if (config === true)\n    return Logger(name, level)\n  if (isString(config) && config.length > 0)\n    return Logger(config, level)\n  if (isNumber(config))\n    return Logger(name, config)\n  if (typeof config === 'function')\n    return config\n  return Logger(name, false)\n}\n"]}

package/dist/chunk-GILR5DT5.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _chunkBQ66KUDGcjs = require('./chunk-BQ66KUDG.cjs');var _chunkDLVWYIS2cjs = require('./chunk-DLVWYIS2.cjs');var _chunkZEDMMWJIcjs = require('./chunk-ZEDMMWJI.cjs');var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');function I(a){let[t,r,m,...e]=a;return{timestamp:t,level:r,name:m,messages:e}}_chunkP7XCQ7WVcjs.a.call(void 0, I,"logMessageFromCompact");function C(a){let{level:t=void 0,filter:r=void 0,compact:m=!1,messages:e=[],errorTrace:u=!1,maxDepth:f=20,keepAsIs:L}=a,M=_chunkDLVWYIS2cjs.b.call(void 0, r),d=_chunkDLVWYIS2cjs.d.call(void 0, t),l=_nullishCoalesce(a.limit, () => (Number.POSITIVE_INFINITY));return o=>{if(!d(o.level)||!M(o.name))return;o.timestamp??=_chunkZEDMMWJIcjs.b.call(void 0, );let s=_chunkBQ66KUDGcjs.h.call(void 0, o,{maxDepth:f,errorTrace:u,keepAsIs:L});m===!0?e.push([s.timestamp,s.level,s.name,...s.messages]):e.push(s),l<=0?e.shift():--l}}_chunkP7XCQ7WVcjs.a.call(void 0, C,"LoggerMemoryHandler");exports.a = I; exports.b = C;
-//# sourceMappingURL=chunk-GILR5DT5.cjs.map

package/dist/chunk-GILR5DT5.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-GILR5DT5.cjs","../src/common/log/log-memory.ts"],"names":["logMessageFromCompact","m","timestamp","level","name","messages","__name","LoggerMemoryHandler","opt","filter","compact","errorTrace","maxDepth","keepAsIs","matchesNamespace","useNamespaceFilter","matchesLevel","useLevelFilter","counter","msg","getTimestamp","objectPlain"],"mappings":"AAAA,qOAAwC,wDAAgD,wDAAyC,wDAAyC,SCK1JA,CAAAA,CAAsBC,CAAAA,CAAkC,CACtE,GAAM,CAACC,CAAAA,CAAWC,CAAAA,CAAOC,CAAAA,CAAM,GAAGC,CAAQ,CAAA,CAAIJ,CAAAA,CAC9C,MAAO,CAAE,SAAA,CAAAC,CAAAA,CAAW,KAAA,CAAAC,CAAAA,CAAO,IAAA,CAAAC,CAAAA,CAAM,QAAA,CAAAC,CAAS,CAC5C,CAHgBC,iCAAAA,CAAAN,CAAA,uBAAA,CAAA,CAMT,SAASO,CAAAA,CACdC,CAAAA,CAQY,CACZ,GAAM,CAAE,KAAA,CAAAL,CAAAA,CAAQ,KAAA,CAAA,CAAW,MAAA,CAAAM,CAAAA,CAAS,KAAA,CAAA,CAAW,OAAA,CAAAC,CAAAA,CAAU,CAAA,CAAA,CAAO,QAAA,CAAAL,CAAAA,CAAW,CAAC,CAAA,CAAG,UAAA,CAAAM,CAAAA,CAAa,CAAA,CAAA,CAAO,QAAA,CAAAC,CAAAA,CAAW,EAAA,CAAI,QAAA,CAAAC,CAAS,CAAA,CAAIL,CAAAA,CACzHM,CAAAA,CAAmBC,iCAAAA,CAAyB,CAAA,CAC5CC,CAAAA,CAAeC,iCAAAA,CAAoB,CAAA,CAErCC,CAAAA,kBAAUV,CAAAA,CAAI,KAAA,SAAS,MAAA,CAAO,mBAAA,CAElC,OAAQW,CAAAA,EAAoB,CAG1B,EAAA,CAFI,CAACH,CAAAA,CAAaG,CAAAA,CAAI,KAAK,CAAA,EAEvB,CAACL,CAAAA,CAAiBK,CAAAA,CAAI,IAAI,CAAA,CAC5B,MAAA,CAEFA,CAAAA,CAAI,SAAA,GAAcC,iCAAAA,CAAa,CAE/B,IAAMnB,CAAAA,CAAIoB,iCAAAA,CAAYF,CAAK,CACzB,QAAA,CAAAP,CAAAA,CACA,UAAA,CAAAD,CAAAA,CACA,QAAA,CAAAE,CACF,CAAC,CAAA,CAEGH,CAAAA,GAAY,CAAA,CAAA,CACbL,CAAAA,CAAiC,IAAA,CAAK,CAACJ,CAAAA,CAAE,SAAA,CAAWA,CAAAA,CAAE,KAAA,CAAOA,CAAAA,CAAE,IAAA,CAAM,GAAGA,CAAAA,CAAE,QAAQ,CAAC,CAAA,CAEnFI,CAAAA,CAA0B,IAAA,CAAKJ,CAAC,CAAA,CAE/BiB,CAAAA,EAAW,CAAA,CACbb,CAAAA,CAAS,KAAA,CAAM,CAAA,CAEf,EAAEa,CACN,CACF,CAxCgBZ,iCAAAA,CAAAC,CAAA,qBAAA,CAAA,CAAA,6BAAA","file":"/Users/dirk/work/github-zeed/dist/chunk-GILR5DT5.cjs","sourcesContent":[null,"import type { LogHandler, LogHandlerOptions, LogMessage, LogMessageCompact } from './log-base'\nimport { objectPlain } from '../data/object'\nimport { getTimestamp } from '../time'\nimport { useLevelFilter, useNamespaceFilter } from './log-filter'\n\nexport function logMessageFromCompact(m: LogMessageCompact): LogMessage {\n  const [timestamp, level, name, ...messages] = m\n  return { timestamp, level, name, messages }\n}\n\n/** Collect messages in a list. */\nexport function LoggerMemoryHandler(\n  opt: LogHandlerOptions & {\n    compact?: boolean\n    messages: LogMessageCompact[] | LogMessage[]\n    errorTrace?: boolean\n    limit?: number\n    maxDepth?: number\n    keepAsIs?: (v: any) => boolean\n  },\n): LogHandler {\n  const { level = undefined, filter = undefined, compact = false, messages = [], errorTrace = false, maxDepth = 20, keepAsIs } = opt\n  const matchesNamespace = useNamespaceFilter(filter)\n  const matchesLevel = useLevelFilter(level)\n\n  let counter = opt.limit ?? Number.POSITIVE_INFINITY\n\n  return (msg: LogMessage) => {\n    if (!matchesLevel(msg.level))\n      return\n    if (!matchesNamespace(msg.name))\n      return\n\n    msg.timestamp ??= getTimestamp()\n\n    const m = objectPlain(msg, {\n      maxDepth,\n      errorTrace,\n      keepAsIs, // : v => (v instanceof Error) || (typeof ErrorEvent !== 'undefined' && v instanceof ErrorEvent),\n    })\n\n    if (compact === true)\n      (messages as LogMessageCompact[]).push([m.timestamp, m.level, m.name, ...m.messages])\n    else\n      (messages as LogMessage[]).push(m)\n\n    if (counter <= 0)\n      messages.shift()\n    else\n      --counter\n  }\n}\n"]}

package/dist/chunk-GMRDD36O.js

@@ -1,2 +0,0 @@
-import{a as l}from"./chunk-5NKC2EQJ.js";function n(){if(typeof self<"u")return self;if(typeof window<"u")return window;if(typeof global<"u")return global;if(typeof globalThis<"u")return globalThis;throw new Error("unable to locate global object")}l(n,"_global");function t(o={}){let e=n();return e._zeedGlobal==null&&(e._zeedGlobal=o),e._zeedGlobal}l(t,"getGlobalContext");var a=globalThis;export{t as a,a as b};
-//# sourceMappingURL=chunk-GMRDD36O.js.map

package/dist/chunk-GMRDD36O.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/global.ts"],"sourcesContent":["/* eslint-disable no-restricted-globals */\n\n/**\n * Global context for Zeed, used for cross-module state.\n * @category Global\n */\n\n// Export the global context type so TypeDoc includes it in the docs.\nexport interface ZeedGlobalContext {\n  [key: string]: any\n}\n\ndeclare global {\n  interface ZeedGlobalContext {}\n}\n\ninterface ZeedGlobalIntegration {\n  _zeedGlobal?: ZeedGlobalContext\n}\n\n/** Identify the right global for the environment. Might be obsolete these days, due to globalThis. */\nfunction _global(): ZeedGlobalIntegration {\n  if (typeof self !== 'undefined')\n    return self as ZeedGlobalIntegration\n  if (typeof window !== 'undefined')\n    return window as ZeedGlobalIntegration\n  if (typeof global !== 'undefined')\n    return global as ZeedGlobalIntegration\n  if (typeof globalThis !== 'undefined')\n    return globalThis as ZeedGlobalIntegration\n  throw new Error('unable to locate global object')\n}\n\n/** Global object to work across module boundaries as well. Internally already used for logger and emitter. */\nexport function getGlobalContext<T = ZeedGlobalContext>(defaultValue = {}): T {\n  const gcontext = _global()\n  if (gcontext._zeedGlobal == null)\n    gcontext._zeedGlobal = defaultValue\n  return gcontext._zeedGlobal as T\n}\n\n/// Last resort hack to extend the globalThis object.\nexport const globalAny = globalThis as any\n"],"mappings":"wCAqBA,SAASA,GAAiC,CACxC,GAAI,OAAO,KAAS,IAClB,OAAO,KACT,GAAI,OAAO,OAAW,IACpB,OAAO,OACT,GAAI,OAAO,OAAW,IACpB,OAAO,OACT,GAAI,OAAO,WAAe,IACxB,OAAO,WACT,MAAM,IAAI,MAAM,gCAAgC,CAClD,CAVSC,EAAAD,EAAA,WAaF,SAASE,EAAwCC,EAAe,CAAC,EAAM,CAC5E,IAAMC,EAAWJ,EAAQ,EACzB,OAAII,EAAS,aAAe,OAC1BA,EAAS,YAAcD,GAClBC,EAAS,WAClB,CALgBH,EAAAC,EAAA,oBAQT,IAAMG,EAAY","names":["_global","__name","getGlobalContext","defaultValue","gcontext","globalAny"]}

package/dist/chunk-H4WNOG2M.js

@@ -1,2 +0,0 @@
-import{a as F}from"./chunk-6EQDC7VW.js";import{a as r}from"./chunk-5NKC2EQJ.js";var I=1,k=(e=>(e[e.request=1]="request",e[e.event=2]="event",e[e.resolve=3]="resolve",e[e.reject=4]="reject",e))(k||{}),E=r(p=>p,"defaultSerialize"),B=E;function w(p,u,y=[]){let{log:g,post:e,on:x,serialize:f=E,deserialize:C=B,timeout:P=6e4,onError:b,onTimeoutError:H,onlyEvents:j=!1,exceptions:T=!0,stringHashPool:R}=p;R&&Object.keys(u).forEach(R.hash);function z(o){}r(z,"checkEventNames");function O(o){Object.assign(u,o??{}),R&&Object.keys(o).forEach(R.hash)}r(O,"registerFunctions");function L(o){y.push(...o)}r(L,"registerEventNames");let d=new Map;return x(async o=>{try{let t=await C(o),l=t?.[0],n=l===2?0:t?.[1],[a,...m]=t.slice(l===2?1:2),h=R?.stringForHash(a)??a;if(l===1||l===2){let s,i;if(a!=null)try{let c=u[h];s=await c(...m)}catch(c){i=String(c)}else i="Method implementation missing";if(i&&(g?.warn("error",t,i),b?.(i,a??"",m)),n>0){let c=await f(i?[4,n,i]:[3,n,s]);await e(c)}}else if(n){let s=d.get(n);s!=null&&(clearTimeout(s.timeoutId),l===4&&T===!0?s.reject(a):s.resolve(a)),d.delete(n)}}catch(t){g?.warn("Error on handling RPC data. Invalid?",t,o)}}),{post:e,serialize:f,rpcPromiseMap:d,proxyHandler:{get(o,t){let l=R?.hash(t)??t,n=r(async(...m)=>await e(await f([2,l,...m])),"sendEvent");if(j||y.includes(t))return n.asEvent=n,n;let a=r(async(...m)=>{let[h,s,i]=F(),c=I++,v;P>=0&&(v=setTimeout(()=>{try{throw H?.(t,m),new Error(`rpc timeout on calling "${t}"`)}catch(A){T===!0?i(A):s(void 0)}d.delete(c),clearTimeout(v),v=void 0},P).unref?.()),d.set(c,{resolve:s,reject:i,timeoutId:v});let M=await f([1,c,l,...m]);return await e(M),h},"sendCall");return a.asEvent=n,a}},registerFunctions:O,registerEventNames:L}}r(w,"setupRPCBasic");function N(p,u){let{eventNames:y=[]}=u,{proxyHandler:g}=w(u,p,y);return new Proxy({},g)}r(N,"useRPC");function U(p){let u=[],y={},{proxyHandler:g,registerFunctions:e,registerEventNames:x}=w(p,y,u);function f(){return new Proxy({},g)}return r(f,"createRPCProxy"),function(C,P=[]){return e(C??{}),x(P),f()}}r(U,"useRPCHub");export{k as a,N as b,U as c};
-//# sourceMappingURL=chunk-H4WNOG2M.js.map

package/dist/chunk-H4WNOG2M.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/msg/rpc.ts"],"sourcesContent":["// From https://github.com/antfu/birpc/blob/main/src/index.ts MIT\n\nimport type { UseStringHashPool } from '../data/string-hash-pool'\nimport type { LoggerInterface } from '../log/log-base'\nimport type { Pipe } from './pipe'\nimport { createPromise } from '../exec/promise'\n\nexport type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never\nexport type ReturnType<T> = T extends (...args: any) => infer R ? R : never\n\nexport interface RPCOptionsBasic extends Pipe {\n  /** No return values expected */\n  onlyEvents?: boolean\n  /** Maximum timeout for waiting for response, in milliseconds */\n  timeout?: number\n  /** Custom logger */\n  log?: LoggerInterface\n  /** Custom error handler */\n  onError?: (error: Error, functionName: string, args: any[]) => boolean | void\n  /** Custom error handler for timeouts */\n  onTimeoutError?: (functionName: string, args: any[]) => boolean | void\n  /** Throw execptions. Default: true */\n  exceptions?: boolean\n  /**  */\n  stringHashPool?: UseStringHashPool\n}\n\nexport interface RPCOptions<Remote> extends RPCOptionsBasic {\n  // /** No return values expected */\n  // onlyEvents?: boolean\n  /** Names of remote functions that do not need response. */\n  eventNames?: (keyof Remote)[]\n}\n\nexport interface RPCFn<T> {\n  /** Call the remote function and wait for the result. */\n  (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>>\n  /** Send event without asking for response */\n  asEvent: (...args: ArgumentsType<T>) => void\n}\n\nexport type RPCReturn<RemoteFunctions> = {\n  [K in keyof RemoteFunctions]: RPCFn<RemoteFunctions[K]>\n}\n\nlet rpcCounter = 1\n\nexport enum RPCMode {\n  request = 1,\n  event = 2,\n  resolve = 3,\n  reject = 4,\n}\n\nexport type RPCMessage = [\n  mode: RPCMode,\n  id: number,\n  method: string | number | any,\n  ...any,\n]\n\nconst defaultSerialize = (i: any) => i\nconst defaultDeserialize = defaultSerialize\n\nfunction setupRPCBasic(options: RPCOptionsBasic, functions: Record<string, (...args: any) => Promise<any>>, eventNames: string[] = []) {\n  const {\n    log,\n    post,\n    on,\n    serialize = defaultSerialize,\n    deserialize = defaultDeserialize,\n    timeout = 60e3,\n    onError,\n    onTimeoutError,\n    onlyEvents = false,\n    exceptions = true,\n    stringHashPool,\n  } = options\n\n  if (stringHashPool) {\n    Object.keys(functions).forEach(stringHashPool.hash)\n  }\n\n  function checkEventNames(eventNames: string[]) {\n    // eventNames.forEach((n) => {\n    //   if (functions[n] == null)\n    //     throw new Error(`event name ${n} has no registered function`)\n    // })\n  }\n\n  checkEventNames(eventNames)\n\n  function registerFunctions(additionalFunctions: any) {\n    Object.assign(functions, additionalFunctions ?? {})\n    if (stringHashPool)\n      Object.keys(additionalFunctions).forEach(stringHashPool.hash)\n  }\n\n  function registerEventNames(additionalEventNames: string[]) {\n    checkEventNames(additionalEventNames)\n    eventNames.push(...additionalEventNames)\n  }\n\n  const rpcPromiseMap = new Map<number, {\n    resolve: (...args: any) => any\n    reject: (...args: any) => any\n    timeoutId: Parameters<typeof clearTimeout>[0]\n  }>()\n\n  on(async (data) => {\n    try {\n      const msg = await deserialize(data) as RPCMessage\n      const mode = msg?.[0]\n      const id = mode === RPCMode.event ? 0 : msg?.[1]\n      const [method, ...args] = msg.slice(mode === RPCMode.event ? 1 : 2)\n      const methodName = stringHashPool?.stringForHash(method) ?? method\n      if (mode === RPCMode.request || mode === RPCMode.event) {\n        let result, error: any\n        if (method != null) {\n          try {\n            const fn = functions[methodName]\n            result = await fn(...args)\n          }\n          catch (e) {\n            error = String(e)\n          }\n        }\n        else {\n          error = 'Method implementation missing'\n        }\n        if (error) {\n          log?.warn('error', msg, error)\n          onError?.(error, method ?? '', args)\n        }\n        if (id > 0) {\n          const data = await serialize(error\n            ? [RPCMode.reject, id, error]\n            : [RPCMode.resolve, id, result])\n          await post(data)\n        }\n      }\n      else if (id) {\n        const promise = rpcPromiseMap.get(id)\n        if (promise != null) {\n          clearTimeout(promise.timeoutId)\n          if (mode === RPCMode.reject && exceptions === true)\n            promise.reject(method)\n          else\n            promise.resolve(method)\n        }\n        rpcPromiseMap.delete(id)\n      }\n    }\n    catch (err) {\n      log?.warn('Error on handling RPC data. Invalid?', err, data)\n    }\n  })\n\n  const proxyHandler = {\n    get(_: any, methodName: string) {\n      const method = stringHashPool?.hash(methodName) ?? methodName\n      const sendEvent = async (...args: any[]) => await post(await serialize([RPCMode.event, method, ...args]))\n\n      if (onlyEvents || eventNames.includes(methodName)) {\n        sendEvent.asEvent = sendEvent\n        return sendEvent\n      }\n\n      const sendCall = async (...args: any[]) => {\n        const [promise, resolve, reject] = createPromise()\n        const id = rpcCounter++\n\n        let timeoutId: any\n        if (timeout >= 0) {\n          timeoutId = setTimeout(() => {\n            try {\n              // Custom onTimeoutError handler can throw its own error too\n              onTimeoutError?.(methodName, args)\n              throw new Error(`rpc timeout on calling \"${methodName}\"`)\n            }\n            catch (e) {\n              if (exceptions === true)\n                reject(e)\n              else\n                resolve(undefined)\n            }\n            rpcPromiseMap.delete(id)\n\n            // Garbage Collection https://jakearchibald.com/2024/garbage-collection-and-closures/\n            clearTimeout(timeoutId)\n            timeoutId = undefined\n          }, timeout).unref?.()\n        }\n\n        rpcPromiseMap.set(id, { resolve, reject, timeoutId })\n        const data = await serialize([RPCMode.request, id, method, ...args])\n        await post(data)\n        return promise\n      }\n      sendCall.asEvent = sendEvent\n      return sendCall\n    },\n  }\n\n  return {\n    post,\n    serialize,\n    rpcPromiseMap,\n    proxyHandler,\n    registerFunctions,\n    registerEventNames,\n  }\n}\n\nexport function useRPC<LocalFunctions, RemoteFunctions = LocalFunctions>(\n  functions: LocalFunctions,\n  options: RPCOptions<RemoteFunctions>,\n): RPCReturn<RemoteFunctions> {\n  const { eventNames = [] } = options\n\n  const { proxyHandler } = setupRPCBasic(options, functions as any, eventNames as any)\n\n  return new Proxy({}, proxyHandler)\n}\n\nexport function useRPCHub(options: RPCOptionsBasic) {\n  const eventNames: string[] = []\n  const functions: Record<string, any> = {}\n\n  const {\n    proxyHandler,\n    registerFunctions,\n    registerEventNames,\n  } = setupRPCBasic(options, functions, eventNames)\n\n  function createRPCProxy() {\n    return new Proxy({}, proxyHandler)\n  }\n\n  return function<LocalFunctions, RemoteFunctions = LocalFunctions>(\n    additionalFunctions?: LocalFunctions,\n    additionalEventNames: string[] = [],\n  ): RPCReturn<RemoteFunctions> {\n    registerFunctions(additionalFunctions ?? {})\n    registerEventNames(additionalEventNames)\n    return createRPCProxy()\n  }\n}\n\nexport type UseRPCHubType = ReturnType<typeof useRPCHub>\n\n// Syntax test case\n// async function _demo() {\n//   const hub: UseRPCHubType = {} as any\n//   const x = hub({\n//     test(name: string): string {\n//       return name\n//     },\n//   })\n//   await x.test('dsd')\n// }\n"],"mappings":"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","names":["rpcCounter","RPCMode","defaultSerialize","__name","i","defaultDeserialize","setupRPCBasic","options","functions","eventNames","log","post","on","serialize","deserialize","timeout","onError","onTimeoutError","onlyEvents","exceptions","stringHashPool","checkEventNames","registerFunctions","additionalFunctions","registerEventNames","additionalEventNames","rpcPromiseMap","data","msg","mode","id","method","args","methodName","result","error","fn","e","promise","err","_","sendEvent","sendCall","resolve","reject","createPromise","timeoutId","useRPC","proxyHandler","useRPCHub","createRPCProxy"]}

package/dist/chunk-HBA5M76N.js

@@ -1,3 +0,0 @@
-import{e as a}from"./chunk-GAJVPW4Z.js";import{a as s}from"./chunk-CU3XJDAD.js";import{b as l}from"./chunk-UVILAVID.js";import{d as n}from"./chunk-6VFFIKPT.js";import{a as f}from"./chunk-5NKC2EQJ.js";var m={string:"String",number:"Double",int:"Int",boolean:"Bool"};function _(i,p="Example"){l(a(i),"schema should be a flat object");let r="";i._meta?.swiftProtocol&&(r=`: ${i._meta.swiftProtocol}`);let o=[`struct ${i._meta?.swiftName??p}${r} {`];return s(i._object,(u,t)=>{let e=`  var ${u}: ${m[t.type]??t.type}`;t._optional===!0&&(e+="?"),(t._meta?.swiftDefault||t._default!=null&&n(t._default))&&(e+=` = ${t._meta?.swiftDefault??JSON.stringify(t._default)}`),o.push(e)}),o.push("}"),o.join(`
-`)}f(_,"schemaExportSwiftStruct");export{_ as a};
-//# sourceMappingURL=chunk-HBA5M76N.js.map

package/dist/chunk-HBA5M76N.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/schema/export-swift.ts"],"sourcesContent":["import type { Type } from './schema'\nimport { assert } from '../assert'\nimport { isPrimitive } from '../data'\nimport { objectMap } from '../data/object'\nimport { isSchemaObjectFlat } from './utils'\n\ndeclare module './schema' {\n  interface TypeMeta {\n    swiftName?: string\n    swiftProtocol?: string\n    swiftDesc?: string\n    swiftDefault?: string\n  }\n}\n\nconst mapSwiftType = {\n  string: 'String',\n  number: 'Double',\n  int: 'Int',\n  boolean: 'Bool',\n} as any\n\nexport function schemaExportSwiftStruct<T>(schema: Type<T>, name: string = 'Example'): string {\n  assert(isSchemaObjectFlat(schema), 'schema should be a flat object')\n\n  let protocol = ''\n  if (schema._meta?.swiftProtocol) {\n    protocol = `: ${schema._meta.swiftProtocol}`\n  }\n\n  const lines: string[] = [\n    `struct ${schema._meta?.swiftName ?? name}${protocol} {`,\n  ]\n\n  objectMap(schema._object!, (key, schema: Type<any>) => {\n    let s = `  var ${key}: ${mapSwiftType[schema.type] ?? schema.type}`\n    if (schema._optional === true)\n      s += '?'\n    if (schema._meta?.swiftDefault || (schema._default != null && isPrimitive(schema._default)))\n      s += ` = ${schema._meta?.swiftDefault ?? JSON.stringify(schema._default)}`\n    lines.push(s)\n  })\n\n  lines.push('}')\n\n  return lines.join('\\n')\n}\n"],"mappings":"wMAeA,IAAMA,EAAe,CACnB,OAAQ,SACR,OAAQ,SACR,IAAK,MACL,QAAS,MACX,EAEO,SAASC,EAA2BC,EAAiBC,EAAe,UAAmB,CAC5FC,EAAOC,EAAmBH,CAAM,EAAG,gCAAgC,EAEnE,IAAII,EAAW,GACXJ,EAAO,OAAO,gBAChBI,EAAW,KAAKJ,EAAO,MAAM,aAAa,IAG5C,IAAMK,EAAkB,CACtB,UAAUL,EAAO,OAAO,WAAaC,CAAI,GAAGG,CAAQ,IACtD,EAEA,OAAAE,EAAUN,EAAO,QAAU,CAACO,EAAKP,IAAsB,CACrD,IAAIQ,EAAI,SAASD,CAAG,KAAKT,EAAaE,EAAO,IAAI,GAAKA,EAAO,IAAI,GAC7DA,EAAO,YAAc,KACvBQ,GAAK,MACHR,EAAO,OAAO,cAAiBA,EAAO,UAAY,MAAQS,EAAYT,EAAO,QAAQ,KACvFQ,GAAK,MAAMR,EAAO,OAAO,cAAgB,KAAK,UAAUA,EAAO,QAAQ,CAAC,IAC1EK,EAAM,KAAKG,CAAC,CACd,CAAC,EAEDH,EAAM,KAAK,GAAG,EAEPA,EAAM,KAAK;AAAA,CAAI,CACxB,CAxBgBK,EAAAX,EAAA","names":["mapSwiftType","schemaExportSwiftStruct","schema","name","assert","isSchemaObjectFlat","protocol","lines","objectMap","key","s","isPrimitive","__name"]}

package/dist/chunk-HEYAOG5D.cjs

@@ -1 +0,0 @@
-"use strict";//# sourceMappingURL=chunk-HEYAOG5D.cjs.map

package/dist/chunk-HEYAOG5D.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-HEYAOG5D.cjs"],"names":[],"mappings":"AAAA","file":"/Users/dirk/work/github-zeed/dist/chunk-HEYAOG5D.cjs"}

package/dist/chunk-HMB2NUKL.js

@@ -1,2 +0,0 @@
-import{a as C}from"./chunk-NG3WB2CM.js";import{b as N,c as x}from"./chunk-D3NCJPFL.js";import{a as p,b as s,c as H,d as I,e as m,f as y}from"./chunk-RZR3ECDT.js";import{q as F}from"./chunk-6VFFIKPT.js";import{a as n}from"./chunk-5NKC2EQJ.js";function h($=""){let u=[C()],d=n(e=>!0,"logCheckNamespace"),i=!1,a=v,b=!1;function v(e="",c){let f=x(c??-1);function t(r,L){return f<=r?L:()=>{}}n(t,"defineForLogLevel");let g=n(r=>{if(d(e))for(let L of u)L&&L(r)},"emit"),l=t(0,(...r)=>{g({name:e,messages:r,level:0})});return l.label=e,l.extend=function(r){return a(e?`${e}:${r}`:r)},l.debug=t(0,(...r)=>{g({name:e,messages:r,level:0})}),l.info=t(1,(...r)=>{g({name:e,messages:r,level:1})}),l.warn=t(2,(...r)=>{g({name:e,messages:r,level:2})}),l.error=t(3,(...r)=>{g({name:e,messages:r,level:3})}),l.fatal=t(4,(...r)=>{throw g({name:e,messages:r,level:4}),new Error(`${r.map(String).join(" ")}`)}),l.assert=t(4,(r,...L)=>{(r==null||typeof r=="number"&&Number.isNaN(r)||!r)&&l.fatal(...L)}),l}n(v,"LoggerBaseFactory");function o(e="",c){let f=a(e,c);return b&&f.debug(`+++ init of logger "${e}" on level "${f.level}".`),f}return n(o,"Logger"),o.registerHandler=function(e){u.push(e)},o.setFilter=function(e){d=N(e)},o.setLock=(e=!0)=>i=e,o.setDebug=(e=!0)=>b=e,o.setHandlers=e=>{a!==v&&(a=v),e!=null&&!i&&(u=[...e].filter(F))},o.level=-1,o.setLogLevel=function(e=-1){i||(o.level=e)},o.setFactory=function(e){i||(a=e)},o}n(h,"LoggerContext");export{h as a};
-//# sourceMappingURL=chunk-HMB2NUKL.js.map

package/dist/chunk-HMB2NUKL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/log/log-context.ts"],"sourcesContent":["import type { LoggerContextInterface, LoggerInterface, LogHandler, LogLevel, LogLevelAliasType, LogMessage } from './log-base'\nimport { isNotNull } from '../data/is'\nimport { LogLevelAll, LogLevelDebug, LogLevelError, LogLevelFatal, LogLevelInfo, LogLevelWarn } from './log-base'\nimport { LoggerConsoleHandler } from './log-console'\nimport { parseLogLevel, useNamespaceFilter } from './log-filter'\n\nexport function LoggerContext(_prefix = ''): LoggerContextInterface {\n  let logHandlers: LogHandler[] = [LoggerConsoleHandler()]\n  let logCheckNamespace = (_name: string) => true\n  let logLock = false\n  let logFactory = LoggerBaseFactory\n  let logDebug = false\n\n  function LoggerBaseFactory(\n    name = '',\n    level?: LogLevelAliasType,\n  ): LoggerInterface {\n    const logLevel = parseLogLevel(level ?? LogLevelAll)\n\n    function defineForLogLevel(fnLevel: LogLevel, fn: any) {\n      if (logLevel <= fnLevel)\n        return fn\n      return () => {}\n    }\n\n    const emit = (msg: LogMessage) => {\n      if (logCheckNamespace(name)) {\n        for (const handler of logHandlers) {\n          if (handler)\n            handler(msg)\n        }\n      }\n    }\n\n    const log = defineForLogLevel(LogLevelDebug, (...messages: any[]) => {\n      emit({ name, messages, level: LogLevelDebug })\n    })\n\n    // log.generic = function (level: LogLevel, ...messages: any[]) {\n    //   if (logLevel <= level)\n    //     emit({ name, messages, level })\n    // }\n\n    log.label = name\n    // log.active = true\n\n    log.extend = function (prefix: string): LoggerInterface {\n      return logFactory(name ? `${name}:${prefix}` : prefix)\n    }\n\n    log.debug = defineForLogLevel(LogLevelDebug, (...messages: any[]) => {\n      emit({ name, messages, level: LogLevelDebug })\n    })\n\n    log.info = defineForLogLevel(LogLevelInfo, (...messages: any[]) => {\n      emit({ name, messages, level: LogLevelInfo })\n    })\n\n    log.warn = defineForLogLevel(LogLevelWarn, (...messages: any[]) => {\n      emit({ name, messages, level: LogLevelWarn })\n    })\n\n    log.error = defineForLogLevel(LogLevelError, (...messages: any[]) => {\n      emit({ name, messages, level: LogLevelError })\n    })\n\n    log.fatal = defineForLogLevel(LogLevelFatal, (...messages: any[]) => {\n      emit({ name, messages, level: LogLevelFatal })\n      throw new Error(`${messages.map(String).join(' ')}`)\n    })\n\n    log.assert = defineForLogLevel(LogLevelFatal, (condition: unknown, ...args: any) => {\n      if (condition == null || (typeof condition === 'number' && Number.isNaN(condition)) || !condition)\n        log.fatal(...args)\n    })\n\n    return log\n  }\n\n  function Logger(name = '', level?: LogLevelAliasType): LoggerInterface {\n    const log = logFactory(name, level)\n    if (logDebug)\n      log.debug(`+++ init of logger \"${name}\" on level \"${log.level}\".`)\n    return log\n  }\n\n  Logger.registerHandler = function (handler: LogHandler) {\n    logHandlers.push(handler)\n  }\n\n  /** @deprecated */\n  Logger.setFilter = function (namespaces: string) {\n    logCheckNamespace = useNamespaceFilter(namespaces)\n  }\n\n  Logger.setLock = (lock = true) => (logLock = lock)\n\n  Logger.setDebug = (debug = true) => (logDebug = debug)\n\n  Logger.setHandlers = (handlers?: (LogHandler | undefined | null)[]) => {\n    if (logFactory !== LoggerBaseFactory)\n      logFactory = LoggerBaseFactory\n    if (handlers != null && !logLock)\n      logHandlers = [...handlers].filter(isNotNull)\n  }\n\n  Logger.level = LogLevelAll\n\n  /** @deprecated */\n  Logger.setLogLevel = function (level: LogLevel = LogLevelAll) {\n    if (logLock)\n      return\n    Logger.level = level\n  }\n\n  Logger.setFactory = function (\n    factory: (name?: string) => LoggerInterface,\n  ): void {\n    if (logLock)\n      return\n    logFactory = factory\n  }\n\n  return Logger\n}\n"],"mappings":"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","names":["LoggerContext","_prefix","logHandlers","LoggerConsoleHandler","logCheckNamespace","__name","_name","logLock","logFactory","LoggerBaseFactory","logDebug","name","level","logLevel","parseLogLevel","defineForLogLevel","fnLevel","fn","emit","msg","handler","log","messages","prefix","condition","args","Logger","namespaces","useNamespaceFilter","lock","debug","handlers","isNotNull","factory"]}

package/dist/chunk-HOPWS6D4.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-HOPWS6D4.js.map

package/dist/chunk-HOPWS6D4.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-HST4VI64.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-HST4VI64.js.map

package/dist/chunk-HST4VI64.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-HT5BUEOF.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-HT5BUEOF.js.map

package/dist/chunk-HT5BUEOF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-HTEAHUXG.cjs

@@ -1,3 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _chunkX764QBCCcjs = require('./chunk-X764QBCC.cjs');var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');function g(e){return e.replace(/^(https?:\/\/(www\.)?|mailto:)/gi,"").replace(/\/$/,"")}_chunkP7XCQ7WVcjs.a.call(void 0, g,"toHumanReadableUrl");var h=/((?:(?:https?|ftp):)?\/\/(?:\S+@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[01])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4])|(?:(?:[a-z0-9\u00A1-\uFFFF][\w\u00A1-\uFFFF-]{0,62})?[a-z0-9\u00A1-\uFFFF]\.)+[a-z\u00A1-\uFFFF]{2,}\.?)(?::\d{2,5})?(?:[/?#]\S*)?)/gi;function k(e){return e.split(h).map((n,i)=>{let t=_chunkX764QBCCcjs.a.call(void 0, n);return i%2?`<a target="_blank" rel="noopener noreferrer" href="${t}">${g(t)}</a>`:t}).join("")}_chunkP7XCQ7WVcjs.a.call(void 0, k,"linkifyPlainTextSimple");var F=/((mailto:)?[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/gi,R=/([a-zA-Z0-9]+\.[a-zA-Z]{2,})/gi;function m(e){var n=e,i=[];let t=n.replace(/[.,!?;:]*$/,"");if(i.unshift(n.slice(t.length)),n.includes("://")){n=t;let p=(n.match(/[\(\[\{]/g)||[]).length,f=(n.match(/[\)\]\}]/g)||[]).length;if(f>p){let x=f-p,$=new RegExp(`[\\)\\]\\}]{0,${x}}$`,"g"),d=n.replace($,"");i.unshift(n.slice(d.length)),n=d}}else n.includes("@")?n.startsWith("mailto:")||(n=`mailto:${t}`):n=`https://${t}`;let r=_chunkX764QBCCcjs.a.call(void 0, i.join("")),s=_chunkX764QBCCcjs.a.call(void 0, g(n)),o=_chunkX764QBCCcjs.a.call(void 0, n);return`<a target="_blank" rel="noopener noreferrer"${n.startsWith("http://")?' class="_warn"':""} href="${o}">${s}</a>${r}`}_chunkP7XCQ7WVcjs.a.call(void 0, m,"handleUrlString");var u=void 0;function y(e,n={}){u==null?u=new RegExp(`((${h.source})|(${F.source})|(${R.source}))`,"gi"):u.lastIndex=0;var i=0;let t=[];return e.replace(u,(r,...s)=>{let o=s[s.length-2],c=_nullishCoalesce(e.slice(i,o), () => (""));return t.push(_chunkX764QBCCcjs.a.call(void 0, c)),i=o+r.length,t.push(m(r)),r}),t.join("")+_chunkX764QBCCcjs.a.call(void 0, e.slice(i))}_chunkP7XCQ7WVcjs.a.call(void 0, y,"linkifyPlainText");function b(e,n={}){return e.split(`
-`).map(i=>y(i,n)).join("<br>")}_chunkP7XCQ7WVcjs.a.call(void 0, b,"linkifyPlainTextWithLineBreaks");function U(e,n){let i=[];for(let[t,r]of Object.entries(e))if(r!=null){Array.isArray(r)||(r=[r]);for(let s of r)n&&!n(s)||s!=null&&i.push(`${encodeURIComponent(t)}=${encodeURIComponent(String(s))}`)}return i.join("&")}_chunkP7XCQ7WVcjs.a.call(void 0, U,"encodeQuery");function I(e){let n={};for(;e.startsWith("?");)e=e.substring(1);let i=e.split("&");for(let t=0;t<i.length;t++){let r=i[t],s=r.indexOf("=");if(r.length===0)continue;let o=s<0?r:decodeURIComponent(r.substring(0,s)),c=s<0?"":decodeURIComponent(r.substring(s+1));n[o]!=null?(Array.isArray(n[o])||(n[o]=[n[o]]),n[o].push(c)):n[o]=c}return n}_chunkP7XCQ7WVcjs.a.call(void 0, I,"parseQuery");exports.a = g; exports.b = h; exports.c = k; exports.d = y; exports.e = b; exports.f = U; exports.g = I;
-//# sourceMappingURL=chunk-HTEAHUXG.cjs.map

package/dist/chunk-HTEAHUXG.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-HTEAHUXG.cjs","../src/common/data/url.ts"],"names":["toHumanReadableUrl","url","__name","RX_URL","linkifyPlainTextSimple","text","part","escapedPart","escapeHTML","RX_EMAIL","RX_SIMPLE_URL","handleUrlString","rests","urlWithoutPunctuation","openingBrackets","closingBrackets","diff","rx","urlWithoutTrailing"],"mappings":"AAAA,qOAAwC,wDAAoC,SCM5DA,CAAAA,CAAmBC,CAAAA,CAAqB,CACtD,OAAOA,CAAAA,CAAI,OAAA,CAAQ,kCAAA,CAAoC,EAAE,CAAA,CAAE,OAAA,CAAQ,KAAA,CAAO,EAAE,CAC9E,CAFgBC,iCAAAA,CAAAF,CAAA,oBAAA,CAAA,CAMT,IAAMG,CAAAA,CAAS,+YAAA,CAGf,SAASC,CAAAA,CAAuBC,CAAAA,CAAsB,CAC3D,OAAOA,CAAAA,CACJ,KAAA,CAAMF,CAAM,CAAA,CACZ,GAAA,CAAI,CAACG,CAAAA,CAAM,CAAA,CAAA,EAAM,CAChB,IAAMC,CAAAA,CAAcC,iCAAAA,CAAe,CAAA,CACnC,OAAO,CAAA,CAAI,CAAA,CACP,CAAA,mDAAA,EAAsDD,CAAW,CAAA,EAAA,EAAKP,CAAAA,CACtEO,CACF,CAAC,CAAA,IAAA,CAAA,CACCA,CACN,CAAC,CAAA,CACA,IAAA,CAAK,EAAE,CACZ,CAZgBL,iCAAAA,CAAAE,CAAA,wBAAA,CAAA,CAgBhB,IAAMK,CAAAA,CAAW,8DAAA,CACXC,CAAAA,CAAgB,gCAAA,CAEtB,SAASC,CAAAA,CAAgBL,CAAAA,CAAsB,CAC7C,IAAIL,CAAAA,CAAMK,CAAAA,CACNM,CAAAA,CAAQ,CAAC,CAAA,CAGb,IAAMC,CAAAA,CAAwBZ,CAAAA,CAAI,OAAA,CAAQ,YAAA,CAAc,EAAE,CAAA,CAI1D,EAAA,CAHAW,CAAAA,CAAM,OAAA,CAAQX,CAAAA,CAAI,KAAA,CAAMY,CAAAA,CAAsB,MAAM,CAAC,CAAA,CAGjDZ,CAAAA,CAAI,QAAA,CAAS,KAAK,CAAA,CAAG,CAGvBA,CAAAA,CAAMY,CAAAA,CACN,IAAMC,CAAAA,CAAAA,CAAmBb,CAAAA,CAAI,KAAA,CAAM,WAAW,CAAA,EAAK,CAAC,CAAA,CAAA,CAAG,MAAA,CACjDc,CAAAA,CAAAA,CAAmBd,CAAAA,CAAI,KAAA,CAAM,WAAW,CAAA,EAAK,CAAC,CAAA,CAAA,CAAG,MAAA,CACvD,EAAA,CAAIc,CAAAA,CAAkBD,CAAAA,CAAiB,CACrC,IAAME,CAAAA,CAAOD,CAAAA,CAAkBD,CAAAA,CACzBG,CAAAA,CAAK,IAAI,MAAA,CAAO,CAAA,cAAA,EAAiBD,CAAI,CAAA,EAAA,CAAA,CAAM,GAAG,CAAA,CAC9CE,CAAAA,CAAqBjB,CAAAA,CAAI,OAAA,CAAQgB,CAAAA,CAAI,EAAE,CAAA,CAC7CL,CAAAA,CAAM,OAAA,CAAQX,CAAAA,CAAI,KAAA,CAAMiB,CAAAA,CAAmB,MAAM,CAAC,CAAA,CAClDjB,CAAAA,CAAMiB,CACR,CAEF,CAAA,KAGSjB,CAAAA,CAAI,QAAA,CAAS,GAAG,CAAA,CAClBA,CAAAA,CAAI,UAAA,CAAW,SAAS,CAAA,EAAA,CAC3BA,CAAAA,CAAM,CAAA,OAAA,EAAUY,CAAqB,CAAA,CAAA;AAmE3B","file":"/Users/dirk/work/github-zeed/dist/chunk-HTEAHUXG.cjs","sourcesContent":[null,"// https://mathiasbynens.be/demo/url-regex\n// https://gist.github.com/dperini/729294\n\nimport { escapeHTML } from './html'\n\n/// Remove scheme, www. and trailing slash for display purposes\nexport function toHumanReadableUrl(url: string): string {\n  return url.replace(/^(https?:\\/\\/(www\\.)?|mailto:)/gi, '').replace(/\\/$/, '')\n}\n\n//\n\nexport const RX_URL = /((?:(?:https?|ftp):)?\\/\\/(?:\\S+@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[01])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4])|(?:(?:[a-z0-9\\u00A1-\\uFFFF][\\w\\u00A1-\\uFFFF-]{0,62})?[a-z0-9\\u00A1-\\uFFFF]\\.)+[a-z\\u00A1-\\uFFFF]{2,}\\.?)(?::\\d{2,5})?(?:[/?#]\\S*)?)/gi\n\n/** @deprecated use linkifyPlainText */\nexport function linkifyPlainTextSimple(text: string): string {\n  return text\n    .split(RX_URL)\n    .map((part, i) => {\n      const escapedPart = escapeHTML(part)\n      return i % 2\n        ? `<a target=\"_blank\" rel=\"noopener noreferrer\" href=\"${escapedPart}\">${toHumanReadableUrl(\n          escapedPart,\n        )}</a>`\n        : escapedPart\n    })\n    .join('')\n}\n\n// Advanced implementation that also handles email addresses and simple URLs without protocol\n\nconst RX_EMAIL = /((mailto:)?[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})/gi\nconst RX_SIMPLE_URL = /([a-zA-Z0-9]+\\.[a-zA-Z]{2,})/gi\n\nfunction handleUrlString(part: string): string {\n  var url = part\n  var rests = []\n\n  // Remove trailing punctuation from URLs\n  const urlWithoutPunctuation = url.replace(/[.,!?;:]*$/, '')\n  rests.unshift(url.slice(urlWithoutPunctuation.length))\n\n  // Full URL with protocol\n  if (url.includes('://')) {\n\n    // Remove trailing closing brackets if unbalanced\n    url = urlWithoutPunctuation\n    const openingBrackets = (url.match(/[\\(\\[\\{]/g) || []).length\n    const closingBrackets = (url.match(/[\\)\\]\\}]/g) || []).length\n    if (closingBrackets > openingBrackets) {\n      const diff = closingBrackets - openingBrackets\n      const rx = new RegExp(`[\\\\)\\\\]\\\\}]{0,${diff}}$`, 'g')\n      const urlWithoutTrailing = url.replace(rx, '')\n      rests.unshift(url.slice(urlWithoutTrailing.length))\n      url = urlWithoutTrailing\n    }\n\n  }\n\n  // Email address\n  else if (url.includes('@')) {\n    if (!url.startsWith('mailto:'))\n      url = `mailto:${urlWithoutPunctuation}`\n  }\n\n  // Simple URL without protocol\n  else {\n    url = `https://${urlWithoutPunctuation}`\n  }\n\n  const escapedRest = escapeHTML(rests.join(''))\n  const escapedHumanReadableUrl = escapeHTML(toHumanReadableUrl(url))\n  const escapedUrl = escapeHTML(url)\n  const classInsecureHttp = url.startsWith('http://') ? ' class=\"_warn\"' : ''\n  return `<a target=\"_blank\" rel=\"noopener noreferrer\"${classInsecureHttp} href=\"${escapedUrl}\">${escapedHumanReadableUrl}</a>${escapedRest}`\n}\n\nvar rxJoined: RegExp | undefined = undefined\n\nexport interface LinkifyOptions {\n}\n\nexport function linkifyPlainText(text: string, options: LinkifyOptions = {}): string {\n  if (rxJoined == null) {\n    rxJoined = new RegExp(`((${RX_URL.source})|(${RX_EMAIL.source})|(${RX_SIMPLE_URL.source}))`, 'gi')\n  } else {\n    rxJoined.lastIndex = 0\n  }\n\n  var index = 0\n  const parts: string[] = []\n\n  text.replace(rxJoined, (match, ...args) => {\n    const offset = args[args.length - 2]\n    const leading = text.slice(index, offset) ?? ''\n    parts.push(escapeHTML(leading))\n    index = offset + match.length\n    parts.push(handleUrlString(match))\n    return match\n  })\n\n  return parts.join('') + escapeHTML(text.slice(index))\n}\n\n\nexport function linkifyPlainTextWithLineBreaks(text: string, options: LinkifyOptions = {}): string {\n  return text.split('\\n').map(l => linkifyPlainText(l, options)).join('<br>')\n}\n\n//\n\nexport function encodeQuery(data: Record<string, any>, filterValue?: (value: any) => boolean) {\n  const pairs = []\n  for (let [key, value] of Object.entries(data)) {\n    if (value != null) {\n      if (!Array.isArray(value))\n        value = [value]\n      for (const v of value) {\n        if (filterValue && !filterValue(v))\n          continue\n        else if (v == null)\n          continue\n        pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(v))}`)\n      }\n    }\n  }\n  return pairs.join('&')\n}\n\nexport function parseQuery(queryString: string) {\n  const query: any = {}\n  while (queryString.startsWith('?')) {\n    queryString = queryString.substring(1)\n  }\n  const pairs = queryString.split('&')\n  for (let i = 0; i < pairs.length; i++) {\n    const part = pairs[i]\n    const idx = part.indexOf('=')\n    if (part.length === 0) continue\n    const key = idx < 0 ? part : decodeURIComponent(part.substring(0, idx))\n    const value = idx < 0 ? '' : decodeURIComponent(part.substring(idx + 1))\n    if (query[key] != null) {\n      if (!Array.isArray(query[key]))\n        query[key] = [query[key]]\n      query[key].push(value)\n    }\n    else {\n      query[key] = value\n    }\n  }\n  return query\n}\n"]}

package/dist/chunk-HZC2RTNS.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');function u(t,n=1e3){if(t<0)throw new Error("Only numbers >= 0 supported");let r=[];do r.unshift((t%n).toString()),t=Math.floor(t/n);while(t>0);return r.unshift(r.length.toString()),r}_chunkP7XCQ7WVcjs.a.call(void 0, u,"distributedFilePath");exports.a = u;
-//# sourceMappingURL=chunk-HZC2RTNS.cjs.map

package/dist/chunk-HZC2RTNS.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-HZC2RTNS.cjs","../src/common/data/distributed.ts"],"names":["distributedFilePath","index","maxEntriesPerFolder","names","__name"],"mappings":"AAAA,iIAAwC,SCQxBA,CAAAA,CAAoBC,CAAAA,CAAeC,CAAAA,CAA8B,GAAA,CAAgB,CAC/F,EAAA,CAAID,CAAAA,CAAQ,CAAA,CACV,MAAM,IAAI,KAAA,CAAM,6BAA6B,CAAA,CAC/C,IAAME,CAAAA,CAAkB,CAAC,CAAA,CACzB,GACEA,CAAAA,CAAM,OAAA,CAAA,CAASF,CAAAA,CAAQC,CAAAA,CAAAA,CAAqB,QAAA,CAAS,CAAC,CAAA,CACtDD,CAAAA,CAAQ,IAAA,CAAK,KAAA,CAAMA,CAAAA,CAAQC,CAAmB,CAAA,CAAA,KAAA,CACvCD,CAAAA,CAAQ,CAAA,CAAA,CACjB,OAAAE,CAAAA,CAAM,OAAA,CAAQA,CAAAA,CAAM,MAAA,CAAO,QAAA,CAAS,CAAC,CAAA,CAC9BA,CACT,CAVgBC,iCAAAA,CAAAJ,CAAA,qBAAA,CAAA,CAAA,cAAA","file":"/Users/dirk/work/github-zeed/dist/chunk-HZC2RTNS.cjs","sourcesContent":[null,"/**\n * Distribute file, named by natural numbers, in a way that each folder only\n * contains `maxEntriesPerFolder` subfolders or files. Returns a list of\n * names, where the last one is the file name, all others are folder names.\n *\n * Example: `distributedFilePath(1003)` results in `['2', '1', '3']` which\n * could be translated to the file path `2/1/3.json`.\n */\nexport function distributedFilePath(index: number, maxEntriesPerFolder: number = 1000): string[] {\n  if (index < 0)\n    throw new Error('Only numbers >= 0 supported')\n  const names: string[] = []\n  do {\n    names.unshift((index % maxEntriesPerFolder).toString())\n    index = Math.floor(index / maxEntriesPerFolder)\n  } while (index > 0)\n  names.unshift(names.length.toString())\n  return names\n}\n"]}

package/dist/chunk-I5HBI6EC.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');function B(o,e=2){let r=["bytes","KiB","MiB","GiB","TiB","PiB","EiB"],n=.0009775171065493646,t=0,i=0;for(o<0&&(o=0);i<n&&t<r.length&&(i=1024**t/o,!(i>=n));t++);return`${(1/i).toFixed(t>0?e:0).toLocaleString()} ${r[t]}`}_chunkP7XCQ7WVcjs.a.call(void 0, B,"formatBytesToHumanBase1024");function a(o,e=2){let r=["bytes","KB","MB","GB","TB","PB","EB"],n=.001001001001001001,t=0,i=0;for(o<0&&(o=0);i<n&&t<r.length&&(i=1e3**t/o,!(i>=n));t++);return`${(1/i).toFixed(t>0?e:0).toLocaleString()} ${r[t]}`}_chunkP7XCQ7WVcjs.a.call(void 0, a,"formatBytesToHumanBase1000");function u(o,e=":"){let r=o<0?"-":"";o<0&&(o=-1*o);let n=Math.floor(o/3600),t=Math.floor(o%3600/60),i=Math.round(o%60);return r+[n,t>9?t:n?`0${t}`:t||"0",i>9?i:`0${i}`].filter(Boolean).join(e)}_chunkP7XCQ7WVcjs.a.call(void 0, u,"formatSecondsToTime");exports.a = B; exports.b = a; exports.c = u;
-//# sourceMappingURL=chunk-I5HBI6EC.cjs.map

package/dist/chunk-I5HBI6EC.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-I5HBI6EC.cjs","../src/common/data/format.ts"],"names":["formatBytesToHumanBase1024","bytes","decimals","units","c","i","h"],"mappings":"AAAA,iIAAwC,SCCxBA,CAAAA,CAA2BC,CAAAA,CAAeC,CAAAA,CAAW,CAAA,CAAG,CAEtE,IAAMC,CAAAA,CAAQ,CAAC,OAAA,CAAS,KAAA,CAAO,KAAA,CAAO,KAAA,CAAO,KAAA,CAAO,KAAA,CAAO,KAAK,CAAA,CAC1DC,CAAAA,CAAI,oBAAA,CACNC,CAAAA,CAAI,CAAA,CACJC,CAAAA,CAAI,CAAA,CAGR,GAAA,CAFIL,CAAAA,CAAQ,CAAA,EAAA,CACVA,CAAAA,CAAQ,CAAA,CAAA,CACHK,CAAAA,CAAIF,CAAAA,EAAKC,CAAAA,CAAIF,CAAAA,CAAM,MAAA,EAAA,CACxBG,CAAAA,CAAI,IAAA,EAAQD,CAAAA,CAAIJ,CAAAA,CACZ,CAAA,CAAAK,CAAAA,EAAKF,CAAAA,CAAAA,CAAAA,CAFuBC,CAAAA,EAAAA,CAEhC,CAGF,MAAQ,CAAA,EAAA","file":"/Users/dirk/work/github-zeed/dist/chunk-I5HBI6EC.cjs","sourcesContent":[null,"/** Just a simple yet fast helper. Alternatively you may use Intl formatters http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat */\nexport function formatBytesToHumanBase1024(bytes: number, decimals = 2) {\n  // https://en.wikipedia.org/wiki/Orders_of_magnitude_(data)\n  const units = ['bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB'] // etc\n  const c = 1 / 1023 // change it to 1024 and see the diff\n  let i = 0\n  let h = 0\n  if (bytes < 0)\n    bytes = 0\n  for (; h < c && i < units.length; i++) {\n    h = 1024 ** i / bytes\n    if (h >= c)\n      break\n  }\n  return (`${(1 / h).toFixed(i > 0 ? decimals : 0).toLocaleString()} ${units[i]}`)\n}\n\n/** Just a simple yet fast helper. Alternatively you may use Intl formatters http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat */\nexport function formatBytesToHumanBase1000(bytes: number, decimals = 2) {\n  // https://en.wikipedia.org/wiki/Orders_of_magnitude_(data)\n  const units = ['bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'] // etc\n  const c = 1 / 999\n  let i = 0\n  let h = 0\n  if (bytes < 0)\n    bytes = 0\n  for (; h < c && i < units.length; i++) {\n    h = 1000 ** i / bytes\n    if (h >= c)\n      break\n  }\n  return (`${(1 / h).toFixed(i > 0 ? decimals : 0).toLocaleString()} ${units[i]}`)\n}\n\n/** Just a simple yet fast helper. Alternatively you may use Intl formatters http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat */\nexport function formatSecondsToTime(seconds: number, separator = ':') {\n  const prefix = seconds < 0 ? '-' : ''\n  if (seconds < 0)\n    seconds = -1 * seconds\n  const h = Math.floor(seconds / 3600)\n  const m = Math.floor((seconds % 3600) / 60)\n  const s = Math.round(seconds % 60)\n  return prefix + [h, m > 9 ? m : h ? `0${m}` : m || '0', s > 9 ? s : `0${s}`].filter(Boolean).join(separator)\n}\n"]}

package/dist/chunk-IA2OMOCB.cjs

@@ -1,5 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);var _path = require('path');var _process = require('process'); var _process2 = _interopRequireDefault(_process);var p=`
-`,E=/^\s*([\w.-]+)\s*=\s*(.*)\s*$/,x=/\\n/g,b=/\r\n|\n|\r/,m=/^\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?$/gm;function h(n){let r={},i=n.toString();i=i.replace(/\r\n?/g,`
-`);let c;for(;(c=m.exec(i))!=null;){let g=c[1],e=c[2]||"";e=e.trim();let t=e[0];e=e.replace(/^(['"`])([\s\S]*)\1$/gm,"$2"),t==='"'&&(e=e.replace(/\\n/g,`
-`),e=e.replace(/\\r/g,"\r")),r[g]=e}return r}_chunkP7XCQ7WVcjs.a.call(void 0, h,"parseEnvStringAlt");function R(n){let r={};return String(n).split(b).forEach((i,c)=>{let g=i.match(E);if(g!=null){let e=g[1],t=g[2]||"",l=t.length-1,s=t[0]==='"'&&t[l]==='"';t[0]==="'"&&t[l]==="'"||s?(t=t.substring(1,l),s&&(t=t.replace(x,p))):t=t.trim(),r[e]=t}}),r}_chunkP7XCQ7WVcjs.a.call(void 0, R,"parseEnvString");function v(n,r="."){return _path.resolve.call(void 0, _process2.default.cwd(),_nullishCoalesce(n, () => (r)))}_chunkP7XCQ7WVcjs.a.call(void 0, v,"stringToPath");function S(n,r=""){return n==null&&(n=r),v(String(n).trim(),r)}_chunkP7XCQ7WVcjs.a.call(void 0, S,"valueToPath");var $=S;function j(n,r=_process2.default.env){if(r[n]!=null)return r[n];n=n.toLowerCase();for(let[i,c]of Object.entries(r))if(i.toLowerCase()===n)return c}_chunkP7XCQ7WVcjs.a.call(void 0, j,"getEnvVariableRelaxed");function w(n={}){let r=_nullishCoalesce(_optionalChain([n, 'optionalAccess', _ => _.path]), () => ($(_nullishCoalesce(_optionalChain([n, 'optionalAccess', _2 => _2.filename]), () => (".env"))))),i=_nullishCoalesce(_optionalChain([n, 'optionalAccess', _3 => _3.encoding]), () => ("utf8")),c=_optionalChain([n, 'optionalAccess', _4 => _4.debug])||!1;try{let t=function(s){return _fs2.default.existsSync(s)?h(_fs2.default.readFileSync(s,{encoding:i})):{}};var g=t;_chunkP7XCQ7WVcjs.a.call(void 0, t,"envOf");let e={};Object.assign(e,t(r),t(`${r}.local`)),n.mode&&Object.assign(e,t(`${r}.${n.mode}`),t(`${r}.${n.mode}.local`));let l=_nullishCoalesce(_optionalChain([n, 'optionalAccess', _5 => _5.env]), () => (_process2.default.env));return Object.entries(e).forEach(([s,f])=>{typeof _optionalChain([n, 'optionalAccess', _6 => _6.prefix])=="string"&&(s=_optionalChain([n, 'optionalAccess', _7 => _7.prefix])+s),Object.prototype.hasOwnProperty.call(l,s)||f!=null&&(l[s]=f)}),{parsed:e}}catch(e){return{error:e}}}_chunkP7XCQ7WVcjs.a.call(void 0, w,"setupEnv");exports.a = h; exports.b = R; exports.c = v; exports.d = S; exports.e = $; exports.f = j; exports.g = w;
-//# sourceMappingURL=chunk-IA2OMOCB.cjs.map

package/dist/chunk-IA2OMOCB.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/chunk-IA2OMOCB.cjs","../src/node/env.ts"],"names":["NEWLINE","RE_INI_KEY_VAL","RE_NEWLINES","NEWLINES_MATCH","LINE","parseEnvStringAlt","src","obj","lines","match","key","value","maybeQuote","__name","parseEnvString","line","idx","keyValueArr","val","end","isDoubleQuoted","stringToPath","defaultValue","resolve","process","valueToPath","toPath","getEnvVariableRelaxed","name","env","k","v","setupEnv","options","dotenvPath","encoding","debug","envOf","fs","parsed"],"mappings":"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","file":"/Users/dirk/work/github-zeed/dist/chunk-IA2OMOCB.cjs","sourcesContent":[null,"// Adopted from https://github.com/motdotla/dotenv BSD-2\n\nimport fs from 'node:fs'\nimport { resolve } from 'node:path'\nimport process from 'node:process'\n\nconst NEWLINE = '\\n'\n// eslint-disable-next-line regexp/no-super-linear-backtracking\nconst RE_INI_KEY_VAL = /^\\s*([\\w.-]+)\\s*=\\s*(.*)\\s*$/\nconst RE_NEWLINES = /\\\\n/g\nconst NEWLINES_MATCH = /\\r\\n|\\n|\\r/\n\nexport interface EnvOptions {\n  /** @deprecated will probably be replaced by logLevel */\n  debug?: boolean\n  path?: string\n  filename?: string\n  encoding?: BufferEncoding\n  prefix?: string\n  env?: Record<string, string>\n  mode?: string\n}\n\n// BSD-2-Clause License from here https://github.com/motdotla/dotenv/blob/master/lib/main.js#L12\n// eslint-disable-next-line regexp/no-super-linear-backtracking\nconst LINE = /^\\s*(?:export\\s+)?([\\w.-]+)(?:\\s*=\\s*?|:\\s+?)(\\s*'(?:\\\\'|[^'])*'|\\s*\"(?:\\\\\"|[^\"])*\"|\\s*`(?:\\\\`|[^`])*`|[^#\\r\\n]+)?\\s*(?:#.*)?$/gm\n\n// https://docs.docker.com/compose/how-tos/environment-variables/variable-interpolation/#env-file-syntax\nexport function parseEnvStringAlt(src: string): Record<string, string> {\n  const obj: Record<string, string> = {}\n\n  // Convert buffer to string\n  let lines = src.toString()\n\n  // Convert line breaks to same format\n  lines = lines.replace(/\\r\\n?/g, '\\n')\n\n  let match\n  // eslint-disable-next-line no-cond-assign\n  while ((match = LINE.exec(lines)) != null) {\n    const key = match[1]\n\n    // Default undefined or null to empty string\n    let value = (match[2] || '')\n\n    // Remove whitespace\n    value = value.trim()\n\n    // Check if double quoted\n    const maybeQuote = value[0]\n\n    // Remove surrounding quotes\n    value = value.replace(/^(['\"`])([\\s\\S]*)\\1$/gm, '$2')\n\n    // Expand newlines if double quoted\n    if (maybeQuote === '\"') {\n      value = value.replace(/\\\\n/g, '\\n')\n      value = value.replace(/\\\\r/g, '\\r')\n    }\n\n    // Add to object\n    obj[key] = value\n  }\n\n  return obj\n}\n// Parses src into an Object\nexport function parseEnvString(src: string) {\n  const obj: Record<string, string> = {}\n\n  // convert Buffers before splitting into lines and processing\n  String(src)\n    .split(NEWLINES_MATCH)\n\n    .forEach((line, idx) => {\n      // matching \"KEY' and 'VAL' in 'KEY=VAL'\n      const keyValueArr = line.match(RE_INI_KEY_VAL)\n      // matched?\n\n      // log.debug(\"keyValueArr\", keyValueArr)\n\n      if (keyValueArr != null) {\n        const key = keyValueArr[1]\n        // default undefined or missing values to empty string\n        let val = keyValueArr[2] || ''\n        const end = val.length - 1\n        const isDoubleQuoted = val[0] === '\"' && val[end] === '\"'\n        const isSingleQuoted = val[0] === '\\'' && val[end] === '\\''\n\n        // if single or double quoted, remove quotes\n        if (isSingleQuoted || isDoubleQuoted) {\n          val = val.substring(1, end)\n\n          // if double quoted, expand newlines\n          if (isDoubleQuoted)\n            val = val.replace(RE_NEWLINES, NEWLINE)\n        }\n        else {\n          // remove surrounding whitespace\n          val = val.trim()\n        }\n        obj[key] = val\n      }\n      // else {\n      //   log.debug(`did not match key and value when parsing line ${idx + 1}: ${line}`)\n      // }\n    })\n\n  // log.debug(\"obj\", obj)\n  return obj\n}\n\n/**\n * Return a path relative to the current working directory\n */\nexport function stringToPath(\n  value?: string,\n  defaultValue = '.',\n): string {\n  return resolve(process.cwd(), value ?? defaultValue)\n}\n\nexport function valueToPath(value?: any, defaultValue = ''): string {\n  if (value == null)\n    value = defaultValue\n  return stringToPath(String(value).trim(), defaultValue)\n}\n\nexport const toPath = valueToPath\n\nexport function getEnvVariableRelaxed(\n  name: string,\n  env = process.env,\n): string | undefined {\n  if (env[name] != null)\n    return env[name]\n  name = name.toLowerCase()\n  for (const [k, v] of Object.entries(env)) {\n    if (k.toLowerCase() === name)\n      return v\n  }\n}\n\n/** Populates process.env from .env file. */\nexport function setupEnv(options: EnvOptions = {}) {\n  const dotenvPath: string = options?.path ?? toPath(options?.filename ?? '.env')\n  const encoding: BufferEncoding = options?.encoding ?? 'utf8'\n  const debug = options?.debug || false\n\n  try {\n    const parsed: Record<string, string> = {}\n\n    function envOf(name: string) {\n      return fs.existsSync(name)\n        ? parseEnvStringAlt(fs.readFileSync(name, { encoding }))\n        : {}\n    }\n\n    Object.assign(\n      parsed,\n      envOf(dotenvPath),\n      envOf(`${dotenvPath}.local`),\n    )\n\n    if (options.mode) {\n      Object.assign(\n        parsed,\n        envOf(`${dotenvPath}.${options.mode}`),\n        envOf(`${dotenvPath}.${options.mode}.local`),\n      )\n    }\n\n    const env = options?.env ?? process.env\n\n    Object.entries(parsed).forEach(([key, value]) => {\n      if (typeof options?.prefix === 'string')\n        key = options?.prefix + key\n\n      if (!Object.prototype.hasOwnProperty.call(env, key)) {\n        if (value != null)\n          env[key] = value\n      }\n      // else {\n      //   log.debug(`\"${key}\" is already defined and will not be overwritten`)\n      // }\n    })\n    return { parsed }\n  }\n  catch (e) {\n    return { error: e }\n  }\n}\n"]}

package/dist/chunk-IBGLNGGT.js

@@ -1,2 +0,0 @@
-import{A as d,b as u,e as U,f as b,g as A,j as B,k as w,l as p,q as l,t as g,w as V}from"./chunk-5WAO44ET.js";import{A as c,b as y,c as I,d as m,h as x,j as E,l as F,o as S,q as P,r as s,s as h,t as T,w as D}from"./chunk-FGAKPO3O.js";import{c as f}from"./chunk-UVILAVID.js";import{G as i}from"./chunk-TXYP3UN6.js";import{a as e}from"./chunk-5NKC2EQJ.js";var J=class{static{e(this,"BinaryEncoder")}async encode(r){let n=y();return c(n,r),m(n)}async decode(r){return d(u(i(r)))}};function q(t){let r=y();return c(r,t),m(r)}e(q,"encodeJson");function v(t){return d(u(i(t)))}e(v,"decodeJson");function z(t){let r=y();return t!=null&&s(r,i(t)),{writeBytes:e((n,a)=>{let o=i(n);f(!(a!=null&&o.length!==a),`Expected ${a} bytes, got ${o.length}`),s(r,o)},"writeBytes"),writeBytesVar:e(n=>h(r,i(n)),"writeBytesVar"),writeUintVar:e(n=>S(r,n),"writeUintVar"),writeUint8:e(n=>x(r,n),"writeUint8"),writeUint16:e(n=>E(r,n),"writeUint16"),writeUint32:e(n=>F(r,n),"writeUint32"),writeIntVar:e(n=>P(r,n),"writeIntVar"),writeFloat:e(n=>D(r,n),"writeFloat"),writeStringVar:e(n=>T(r,n),"writeStringVar"),write:e(n=>c(r,n),"write"),getUint8Array:e(()=>m(r),"getUint8Array"),getLength:e(()=>I(r),"getLength")}}e(z,"createBinaryStreamEncoder");function G(t){let r=u(i(t));return{readBytes:e(n=>U(r,n),"readBytes"),readBytesVar:e(()=>A(r),"readBytesVar"),readUintVar:e(()=>b(r),"readUintVar"),readUint8:e(()=>B(r),"readUint8"),readUint16:e(()=>w(r),"readUint16"),readUint32:e(()=>p(r),"readUint32"),readIntVar:e(()=>l(r),"readIntVar"),readFloat:e(()=>V(r),"readFloat"),readStringVar:e(()=>g(r),"readStringVar"),read:e(()=>d(r),"read"),getOffset:e(()=>r.pos||0,"getOffset")}}e(G,"createBinaryStreamDecoder");function H(t=0){return{setBit:e((r,n=!0)=>n?t|=1<<r:t&=~(1<<r),"setBit"),unsetBit:e(r=>t&=1<<r,"unsetBit"),toggleBit:e(r=>t^=1<<r,"toggleBit"),getBit:e(r=>(t&1<<r)!==0,"getBit"),getValue:e(()=>t,"getValue")}}e(H,"bitfield");async function $(t){if(t.arrayBuffer)return await t.arrayBuffer();try{return new Promise((r,n)=>{try{let a=new FileReader;a.onloadend=()=>r(a.result),a.onerror=o=>n(o),a.onabort=o=>n(o),a.readAsArrayBuffer(t)}catch(a){n(a)}})}catch{}}e($,"blobToArrayBuffer");async function K(t){let r=await $(t);if(r!=null)return i(r)}e(K,"blobToUint8Array");export{J as a,q as b,v as c,z as d,G as e,H as f,$ as g,K as h};
-//# sourceMappingURL=chunk-IBGLNGGT.js.map

package/dist/chunk-IBGLNGGT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/common/bin/index.ts"],"sourcesContent":["import type { BinInput } from '../data/bin-types'\nimport type { Encoder } from '../msg/encoder'\nimport { assertCondition } from '../assert'\nimport { toUint8Array } from '../data/bin'\nimport { createDecoder, readAny, readFloat32, readUint8, readUint8Array, readUint16, readUint32, readVarInt, readVarString, readVarUint, readVarUint8Array } from './lib0/decoding'\nimport { createBinEncoder, encodeToUint8Array, length, writeAny, writeFloat32, writeUint8, writeUint8Array, writeUint16, writeUint32, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array } from './lib0/encoding'\n\n// Use in Zeed channels\n\nexport class BinaryEncoder implements Encoder {\n  async encode(data: any): Promise<Uint8Array> {\n    const dataEncoder = createBinEncoder()\n    writeAny(dataEncoder, data)\n    return encodeToUint8Array(dataEncoder)\n  }\n\n  async decode(data: Uint8Array | ArrayBuffer): Promise<any> {\n    return readAny(createDecoder(toUint8Array(data)))\n  }\n}\n\n// Json like\n\n/** Encode any object, including Uint8Array data */\nexport function encodeJson(data: any): Uint8Array {\n  const dataEncoder = createBinEncoder()\n  writeAny(dataEncoder, data)\n  return encodeToUint8Array(dataEncoder)\n}\n\n/** Decode any object, including Uint8Array data */\nexport function decodeJson(data: Uint8Array | ArrayBuffer): any {\n  return readAny(createDecoder(toUint8Array(data)))\n}\n\n// Stream like\n\n/** Incrementally encode binary data */\nexport function createBinaryStreamEncoder(initialData?: BinInput) {\n  const dataEncoder = createBinEncoder()\n\n  if (initialData != null)\n    writeUint8Array(dataEncoder, toUint8Array(initialData))\n\n  return {\n    /** Just writes the bytes. Length is not stored! */\n    writeBytes: (data: BinInput, expectedLength: number) => {\n      const bin = toUint8Array(data)\n      assertCondition(!(expectedLength != null && bin.length !== expectedLength), `Expected ${expectedLength} bytes, got ${bin.length}`)\n      writeUint8Array(dataEncoder, bin)\n    },\n    writeBytesVar: (data: BinInput) => writeVarUint8Array(dataEncoder, toUint8Array(data)),\n    writeUintVar: (data: number) => writeVarUint(dataEncoder, data),\n    writeUint8: (data: number) => writeUint8(dataEncoder, data),\n    writeUint16: (data: number) => writeUint16(dataEncoder, data),\n    writeUint32: (data: number) => writeUint32(dataEncoder, data),\n    writeIntVar: (data: number) => writeVarInt(dataEncoder, data),\n    writeFloat: (data: number) => writeFloat32(dataEncoder, data),\n    writeStringVar: (data: string) => writeVarString(dataEncoder, data),\n    write: (data: any) => writeAny(dataEncoder, data),\n    getUint8Array: (): Uint8Array => encodeToUint8Array(dataEncoder),\n    getLength: () => length(dataEncoder),\n  }\n}\n\n/** Incrementally decode binary data */\nexport function createBinaryStreamDecoder(data: BinInput) {\n  const dataDecoder = createDecoder(toUint8Array(data))\n  return {\n    readBytes: (len: number): Uint8Array => readUint8Array(dataDecoder, len),\n    readBytesVar: (): Uint8Array => readVarUint8Array(dataDecoder),\n    readUintVar: (): number => readVarUint(dataDecoder),\n    readUint8: (): number => readUint8(dataDecoder),\n    readUint16: (): number => readUint16(dataDecoder),\n    readUint32: (): number => readUint32(dataDecoder),\n    readIntVar: (): number => readVarInt(dataDecoder),\n    readFloat: (): number => readFloat32(dataDecoder),\n    readStringVar: (): string => readVarString(dataDecoder),\n    read: (): any => readAny(dataDecoder),\n    getOffset: (): number => dataDecoder.pos || 0,\n  }\n}\n\n// https://stackoverflow.com/a/1436448/140927\nexport function bitfield(bitfield = 0) {\n  return {\n    setBit: (bit: number, value = true): number => value ? (bitfield |= 1 << bit) : (bitfield &= ~(1 << bit)),\n    unsetBit: (bit: number): number => (bitfield &= 1 << bit),\n    toggleBit: (bit: number): number => (bitfield ^= 1 << bit),\n    getBit: (bit: number): boolean => (bitfield & (1 << bit)) !== 0,\n    getValue: () => bitfield,\n  }\n}\n\n// Cast\n\nexport async function blobToArrayBuffer(blob: Blob | File): Promise<ArrayBuffer | undefined> {\n  if (blob.arrayBuffer)\n    return await blob.arrayBuffer()\n\n  // Fallback for older browsers\n  try {\n    return new Promise((resolve, reject) => {\n      try {\n        const reader = new FileReader()\n        reader.onloadend = () => resolve(reader.result as ArrayBuffer)\n        reader.onerror = err => reject(err)\n        reader.onabort = err => reject(err)\n        reader.readAsArrayBuffer(blob)\n      }\n      catch (err) {\n        reject(err)\n      }\n    })\n  }\n  catch (err) {}\n}\n\nexport async function blobToUint8Array(blob: Blob | File): Promise<Uint8Array | undefined> {\n  const buffer = await blobToArrayBuffer(blob)\n  if (buffer != null)\n    return toUint8Array(buffer)\n}\n"],"mappings":"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","names":["BinaryEncoder","__name","data","dataEncoder","createBinEncoder","writeAny","encodeToUint8Array","readAny","createDecoder","toUint8Array","encodeJson","decodeJson","createBinaryStreamEncoder","initialData","writeUint8Array","expectedLength","bin","assertCondition","writeVarUint8Array","writeVarUint","writeUint8","writeUint16","writeUint32","writeVarInt","writeFloat32","writeVarString","length","createBinaryStreamDecoder","dataDecoder","len","readUint8Array","readVarUint8Array","readVarUint","readUint8","readUint16","readUint32","readVarInt","readFloat32","readVarString","bitfield","bit","value","blobToArrayBuffer","blob","resolve","reject","reader","err","blobToUint8Array","buffer"]}

package/dist/chunk-IJE3VBKC.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _chunk7UA33BQWcjs = require('./chunk-7UA33BQW.cjs');var _chunkP7XCQ7WVcjs = require('./chunk-P7XCQ7WV.cjs');function x(u,f={}){let{delay:o=100,trailing:r=!0,leading:l=!0}=f,t,i=0,s=0,a;function d(){return t?(clearTimeout(t),t=void 0,!0):!1}_chunkP7XCQ7WVcjs.a.call(void 0, d,"clearExistingTimeout");function e(...y){let c=Date.now(),m=c-i,p=_chunkP7XCQ7WVcjs.a.call(void 0, ()=>{s=0,i=Date.now(),u.apply(this,y)},"exec");if(a=p,m>o||!t){l&&(m>o?p():++s);let h=m>o?o:o-m;d(),i=c,t=setTimeout(()=>{d(),r&&(!l||s>0)&&_optionalChain([a, 'optionalCall', _ => _()])},h)}else++s}return _chunkP7XCQ7WVcjs.a.call(void 0, e,"wrapper"),e.cancel=d,e.stop=()=>{d()&&a&&a()},e.immediate=_chunkP7XCQ7WVcjs.a.call(void 0, async function(...c){d(),i=Date.now(),u.apply(this,c)},"immediate"),e.dispose=()=>e.stop(),e}_chunkP7XCQ7WVcjs.a.call(void 0, x,"throttle");function F(u,f={}){let{delay:o=100}=f,r,l=!1,t;function i(){r&&(clearTimeout(r),r=void 0)}_chunkP7XCQ7WVcjs.a.call(void 0, i,"clearExistingTimeout");async function s(){try{if(i(),t!=null){let e=[...t];t=void 0,l=!0,await _chunk7UA33BQWcjs.i.call(void 0, u(...e)),l=!1,t!=null&&(i(),r=setTimeout(s,o))}}catch (e2){}}_chunkP7XCQ7WVcjs.a.call(void 0, s,"exec");function a(...e){t=[...e],i(),l===!1&&(r=setTimeout(s,o))}_chunkP7XCQ7WVcjs.a.call(void 0, a,"wrapper");async function d(...e){i(),t=[...e],await s()}return _chunkP7XCQ7WVcjs.a.call(void 0, d,"immediate"),a.cancel=i,a.dispose=i,a.immediate=d,a}_chunkP7XCQ7WVcjs.a.call(void 0, F,"debounce");exports.a = x; exports.b = F;
-//# sourceMappingURL=chunk-IJE3VBKC.cjs.map