zeed 0.8.2 → 0.8.3

package/dist/chunk-AITOWUS2.cjs

@@ -0,0 +1,3305 @@
+"use strict"; function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var chunkC66X5FP6_cjs = require('./chunk-C66X5FP6.cjs');
+
+// src/common/data/bin.ts
+var log = chunkC66X5FP6_cjs.Logger("bin");
+function _encodeUtf8Polyfill(str) {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    buf[i] = encodedString.codePointAt(i) || 0;
+  }
+  return buf;
+}
+chunkC66X5FP6_cjs.__name(_encodeUtf8Polyfill, "_encodeUtf8Polyfill");
+function _decodeUtf8Polyfill(buf) {
+  let remainingLen = buf.length;
+  let encodedString = "";
+  let bufPos = 0;
+  while (remainingLen > 0) {
+    const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+    const bytes = buf.subarray(bufPos, bufPos + nextLen);
+    bufPos += nextLen;
+    encodedString += String.fromCodePoint.apply(null, bytes);
+    remainingLen -= nextLen;
+  }
+  return decodeURIComponent(escape(encodedString));
+}
+chunkC66X5FP6_cjs.__name(_decodeUtf8Polyfill, "_decodeUtf8Polyfill");
+var _textEncoder;
+function stringToUInt8Array(text) {
+  if (_textEncoder == null) {
+    _textEncoder = _encodeUtf8Polyfill;
+    if (typeof TextEncoder !== "undefined") {
+      const encoder = new TextEncoder();
+      _textEncoder = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((data) => encoder.encode(data), "_textEncoder");
+    }
+  }
+  return _textEncoder(text.normalize("NFC"));
+}
+chunkC66X5FP6_cjs.__name(stringToUInt8Array, "stringToUInt8Array");
+var _textDecoder;
+function Uint8ArrayToString(bin) {
+  if (_textDecoder == null) {
+    _textDecoder = _decodeUtf8Polyfill;
+    if (typeof TextDecoder !== "undefined") {
+      const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+      _textDecoder = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((data) => decoder.decode(data), "_textDecoder");
+    }
+  }
+  return _textDecoder(bin).normalize("NFC");
+}
+chunkC66X5FP6_cjs.__name(Uint8ArrayToString, "Uint8ArrayToString");
+function toUint8Array(data) {
+  if (data instanceof ArrayBuffer)
+    return new Uint8Array(data);
+  if (typeof data === "string")
+    return stringToUInt8Array(data);
+  if (data.length)
+    return new Uint8Array(data);
+  return data;
+}
+chunkC66X5FP6_cjs.__name(toUint8Array, "toUint8Array");
+function joinToUint8Array(...args) {
+  let length = 0;
+  const bins = args.flat(1).map((d) => {
+    const b = toUint8Array(d);
+    length += b.length;
+    return b;
+  });
+  let bin = new Uint8Array(length);
+  let cursor = 0;
+  for (let b of bins) {
+    bin.set(b, cursor);
+    cursor += b.length;
+  }
+  return bin;
+}
+chunkC66X5FP6_cjs.__name(joinToUint8Array, "joinToUint8Array");
+function toHex(bin) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(toUint8Array(bin)).toString("hex");
+  }
+  const h = "0123456789abcdef";
+  let s = "";
+  for (const v of [...toUint8Array(bin)]) {
+    s += h[v >> 4] + h[v & 15];
+  }
+  return s;
+}
+chunkC66X5FP6_cjs.__name(toHex, "toHex");
+function toBase64(bin) {
+  const bytes = toUint8Array(bin);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let s = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    s += String.fromCharCode(bytes[i]);
+  }
+  return btoa(s);
+}
+chunkC66X5FP6_cjs.__name(toBase64, "toBase64");
+function toBase64Url(bin) {
+  const bytes = toUint8Array(bin);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64url");
+  }
+  let s = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    s += String.fromCharCode(bytes[i]);
+  }
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_");
+}
+chunkC66X5FP6_cjs.__name(toBase64Url, "toBase64Url");
+function fromBase64(s) {
+  if (typeof Buffer !== "undefined") {
+    const buf = Buffer.from(s, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  const a = atob(s);
+  const bytes = new Uint8Array(a.length);
+  for (let i = 0; i < a.length; i++) {
+    bytes[i] = a.charCodeAt(i);
+  }
+  return bytes;
+}
+chunkC66X5FP6_cjs.__name(fromBase64, "fromBase64");
+function equalBinary(a, b) {
+  if (a.byteLength !== b.byteLength)
+    return false;
+  const aa = toUint8Array(a);
+  const bb = toUint8Array(b);
+  for (let i = 0; i < aa.length; i++) {
+    if (aa[i] !== bb[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+chunkC66X5FP6_cjs.__name(equalBinary, "equalBinary");
+function jsonToUint8Array(json) {
+  try {
+    return stringToUInt8Array(JSON.stringify(json));
+  } catch (err) {
+    log.warn("jsonToUint8Array", json);
+    throw err;
+  }
+}
+chunkC66X5FP6_cjs.__name(jsonToUint8Array, "jsonToUint8Array");
+function Uint8ArrayToJson(data) {
+  try {
+    return JSON.parse(Uint8ArrayToString(data));
+  } catch (err) {
+    log.warn("Uint8ArrayToJson", data);
+    throw err;
+  }
+}
+chunkC66X5FP6_cjs.__name(Uint8ArrayToJson, "Uint8ArrayToJson");
+function Uint8ArrayToHexDump(buffer, blockSize) {
+  if (typeof buffer === "string") ; else if (buffer instanceof ArrayBuffer && buffer.byteLength !== void 0) {
+    buffer = String.fromCharCode.apply(
+      String,
+      [].slice.call(new Uint8Array(buffer))
+    );
+  } else if (Array.isArray(buffer)) {
+    buffer = String.fromCharCode.apply(String, buffer);
+  } else if (buffer.constructor === Uint8Array) {
+    buffer = String.fromCharCode.apply(String, [].slice.call(buffer));
+  } else {
+    return false;
+  }
+  blockSize = blockSize || 16;
+  var lines = [];
+  var hex = "0123456789ABCDEF";
+  for (var b = 0; b < buffer.length; b += blockSize) {
+    var block = buffer.slice(b, Math.min(b + blockSize, buffer.length));
+    var addr = ("0000" + b.toString(16)).slice(-4);
+    var codes = block.split("").map((ch) => {
+      var code = ch.charCodeAt(0);
+      return " " + hex[(240 & code) >> 4] + hex[15 & code];
+    }).join("");
+    codes += "   ".repeat(blockSize - block.length);
+    var chars = block.replace(/[\x00-\x1F\x20]/g, ".");
+    chars += " ".repeat(blockSize - block.length);
+    lines.push(addr + " " + codes + "  " + chars);
+  }
+  return lines.join("\n");
+}
+chunkC66X5FP6_cjs.__name(Uint8ArrayToHexDump, "Uint8ArrayToHexDump");
+
+// src/common/crypto.ts
+function randomUint8Array(length = 16) {
+  let randomBytes = new Uint8Array(length);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(randomBytes);
+  } else {
+    for (let i = 0; i < length; i++) {
+      randomBytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return randomBytes;
+}
+chunkC66X5FP6_cjs.__name(randomUint8Array, "randomUint8Array");
+var DEFAULT_HASH_ALG = "SHA-256";
+var DEFAULT_CRYPTO_ALG = "AES-GCM";
+var DEFAULT_DERIVE_ALG = "PBKDF2";
+async function digest(message, algorithm = DEFAULT_HASH_ALG) {
+  return toUint8Array(
+    await crypto.subtle.digest(algorithm, toUint8Array(message))
+  );
+}
+chunkC66X5FP6_cjs.__name(digest, "digest");
+async function deriveKeyPbkdf2(secret, opt = {}) {
+  const secretBuffer = toUint8Array(secret);
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    secretBuffer,
+    DEFAULT_DERIVE_ALG,
+    false,
+    ["deriveKey"]
+  );
+  return await crypto.subtle.deriveKey(
+    {
+      name: DEFAULT_DERIVE_ALG,
+      salt: opt.salt ? toUint8Array(opt.salt) : new Uint8Array(0),
+      iterations: _nullishCoalesce(opt.iterations, () => ( 1e5)),
+      hash: DEFAULT_HASH_ALG
+    },
+    keyMaterial,
+    {
+      name: DEFAULT_CRYPTO_ALG,
+      length: 256
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+chunkC66X5FP6_cjs.__name(deriveKeyPbkdf2, "deriveKeyPbkdf2");
+var MAGIC_ID = new Uint8Array([1, 1]);
+async function encrypt(data, key) {
+  const iv = randomUint8Array(12);
+  const cipher = await crypto.subtle.encrypt(
+    { name: DEFAULT_CRYPTO_ALG, iv },
+    key,
+    data
+  );
+  const binCypher = new Uint8Array(cipher);
+  const bufferLength = MAGIC_ID.length + iv.length + binCypher.length;
+  const buffer = new Uint8Array(bufferLength);
+  let pos = 0;
+  buffer.set(MAGIC_ID, pos);
+  pos += MAGIC_ID.length;
+  buffer.set(iv, pos);
+  pos += iv.length;
+  buffer.set(binCypher, pos);
+  return buffer;
+}
+chunkC66X5FP6_cjs.__name(encrypt, "encrypt");
+async function decrypt(data, key) {
+  let magic = data.subarray(0, 2);
+  if (!equalBinary(magic, MAGIC_ID)) {
+    return Promise.reject(`Unknown magic ${magic}`);
+  }
+  let iv = data.subarray(2, 2 + 12);
+  let cipher = data.subarray(2 + 12, data.length);
+  const plain = await crypto.subtle.decrypt(
+    { name: DEFAULT_CRYPTO_ALG, iv },
+    key,
+    cipher
+  );
+  return new Uint8Array(plain);
+}
+chunkC66X5FP6_cjs.__name(decrypt, "decrypt");
+
+// src/common/csv.ts
+var separator = ",";
+function filterFloat(value) {
+  if (/^([-+])?([0-9]+(\.[0-9]+)?|Infinity)$/.test(value)) {
+    return Number(value);
+  }
+  return NaN;
+}
+chunkC66X5FP6_cjs.__name(filterFloat, "filterFloat");
+function escape2(field) {
+  if (field == void 0) {
+    return "";
+  }
+  if (!isNaN(filterFloat(field)) && isFinite(field)) {
+    return parseFloat(field);
+  }
+  return '"' + String(field).replace(/"/g, '""') + '"';
+}
+chunkC66X5FP6_cjs.__name(escape2, "escape");
+function csv(data, headerRow) {
+  let body = "";
+  if (headerRow) {
+    body = headerRow.join(separator) + "\r\n";
+  }
+  for (let i = 0; i < data.length; i++) {
+    body += data[i].map(escape2).join(separator) + "\r\n";
+  }
+  return body;
+}
+chunkC66X5FP6_cjs.__name(csv, "csv");
+
+// src/common/data/math.ts
+function getSecureRandom() {
+  return crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;
+}
+chunkC66X5FP6_cjs.__name(getSecureRandom, "getSecureRandom");
+function getSecureRandomIfPossible() {
+  return typeof crypto !== "undefined" ? getSecureRandom() : Math.random();
+}
+chunkC66X5FP6_cjs.__name(getSecureRandomIfPossible, "getSecureRandomIfPossible");
+function randomBoolean(bias = 0.25) {
+  return getSecureRandomIfPossible() < bias;
+}
+chunkC66X5FP6_cjs.__name(randomBoolean, "randomBoolean");
+function randomInt(max = 100, min = 0) {
+  return min + Math.floor(getSecureRandomIfPossible() * (max - min));
+}
+chunkC66X5FP6_cjs.__name(randomInt, "randomInt");
+function randomFloat(max = 100, min = 0) {
+  return min + getSecureRandomIfPossible() * (max - min);
+}
+chunkC66X5FP6_cjs.__name(randomFloat, "randomFloat");
+function between(min, value, max) {
+  return Math.max(min, Math.min(max, value));
+}
+chunkC66X5FP6_cjs.__name(between, "between");
+function sum(array) {
+  return array.reduce((acc, value) => acc + value, 0);
+}
+chunkC66X5FP6_cjs.__name(sum, "sum");
+function avg(array) {
+  return sum(array) / array.length;
+}
+chunkC66X5FP6_cjs.__name(avg, "avg");
+function isPrimeRX(value) {
+  return !/^1?$|^(11+?)\1+$/.test("1".repeat(value));
+}
+chunkC66X5FP6_cjs.__name(isPrimeRX, "isPrimeRX");
+function isPrime(value) {
+  for (var i = 2; i < value; i++)
+    if (value % i === 0)
+      return false;
+  return value > 1;
+}
+chunkC66X5FP6_cjs.__name(isPrime, "isPrime");
+
+// src/common/data/orderby.ts
+function parseOrderby(value = "") {
+  let [field = "", orderby = "asc"] = value.split(" ");
+  orderby = orderby.toLowerCase();
+  return {
+    field,
+    orderby,
+    asc: orderby !== "desc",
+    desc: orderby === "desc"
+  };
+}
+chunkC66X5FP6_cjs.__name(parseOrderby, "parseOrderby");
+function composeOrderby(field, asc = true) {
+  return `${field} ${asc ? "asc" : "desc"}`;
+}
+chunkC66X5FP6_cjs.__name(composeOrderby, "composeOrderby");
+function cmp(a, b, asc = true) {
+  const aa = a || 0;
+  const bb = b || 0;
+  return aa > bb ? asc ? 1 : -1 : aa < bb ? asc ? -1 : 1 : 0;
+}
+chunkC66X5FP6_cjs.__name(cmp, "cmp");
+function sortedOrderby(values, ...orderby) {
+  if (orderby.length > 0) {
+    let orderByList = orderby.map(parseOrderby);
+    let sortValues = Array.from(values);
+    sortValues.sort((a, b) => {
+      for (let { field, asc } of orderByList) {
+        const result = cmp(a[field], b[field], asc);
+        if (result !== 0)
+          return result;
+      }
+      return 0;
+    });
+    return sortValues;
+  }
+  return values;
+}
+chunkC66X5FP6_cjs.__name(sortedOrderby, "sortedOrderby");
+
+// src/common/data/array.ts
+function arrayUnique(x) {
+  return x.filter((n, index) => x.indexOf(n) === index);
+}
+chunkC66X5FP6_cjs.__name(arrayUnique, "arrayUnique");
+function arrayMinus(x, y) {
+  return arrayUnique(x.filter((n) => !y.includes(n)));
+}
+chunkC66X5FP6_cjs.__name(arrayMinus, "arrayMinus");
+function arrayUnion(...a) {
+  return arrayUnique(a.reduce((acc = [], value) => acc.concat(value), []));
+}
+chunkC66X5FP6_cjs.__name(arrayUnion, "arrayUnion");
+function arrayFlatten(...list) {
+  return list.flat(Infinity);
+}
+chunkC66X5FP6_cjs.__name(arrayFlatten, "arrayFlatten");
+function arrayIntersection(x, y) {
+  return arrayUnique(x).filter((n) => y.includes(n));
+}
+chunkC66X5FP6_cjs.__name(arrayIntersection, "arrayIntersection");
+function arraySymmetricDifference(x, y) {
+  return arrayMinus(arrayUnion(x, y), arrayIntersection(x, y));
+}
+chunkC66X5FP6_cjs.__name(arraySymmetricDifference, "arraySymmetricDifference");
+function arrayRemoveElement(arr, el) {
+  if (arr && Array.isArray(arr)) {
+    let index;
+    while ((index = arr.indexOf(el)) !== -1) {
+      arr.splice(index, 1);
+    }
+    return arr;
+  }
+  return [];
+}
+chunkC66X5FP6_cjs.__name(arrayRemoveElement, "arrayRemoveElement");
+function arraySetElement(arr, el) {
+  if (!arr.includes(el))
+    arr.push(el);
+  return arr;
+}
+chunkC66X5FP6_cjs.__name(arraySetElement, "arraySetElement");
+function arrayFilterInPlace(array, fn) {
+  array.splice(0, array.length, ...array.filter(fn));
+  return array;
+}
+chunkC66X5FP6_cjs.__name(arrayFilterInPlace, "arrayFilterInPlace");
+function arrayToggleInPlace(array, el) {
+  const index = array.findIndex((e) => e === el);
+  if (index >= 0)
+    array.splice(index, 1);
+  else
+    array.push(el);
+  return array;
+}
+chunkC66X5FP6_cjs.__name(arrayToggleInPlace, "arrayToggleInPlace");
+function arrayEmptyInPlace(array) {
+  array.splice(0, array.length);
+  return array;
+}
+chunkC66X5FP6_cjs.__name(arrayEmptyInPlace, "arrayEmptyInPlace");
+function arraySorted(arr, cond = cmp) {
+  return Array.from(arr).sort(cond);
+}
+chunkC66X5FP6_cjs.__name(arraySorted, "arraySorted");
+function arraySortedNumbers(arr) {
+  return arraySorted(arr, (l, r) => l - r);
+}
+chunkC66X5FP6_cjs.__name(arraySortedNumbers, "arraySortedNumbers");
+function arrayIsEqual(array1, array2) {
+  return array1.length === array2.length && array1.every((value, index) => value === array2[index]);
+}
+chunkC66X5FP6_cjs.__name(arrayIsEqual, "arrayIsEqual");
+function arrayShuffleInPlace(array) {
+  array.sort(() => getSecureRandomIfPossible() > 0.5 ? 1 : -1);
+  return array;
+}
+chunkC66X5FP6_cjs.__name(arrayShuffleInPlace, "arrayShuffleInPlace");
+function arrayShuffle(array) {
+  return arrayShuffleInPlace(Array.from(array));
+}
+chunkC66X5FP6_cjs.__name(arrayShuffle, "arrayShuffle");
+function arrayShuffleForce(array) {
+  while (array.length > 1) {
+    const copy = Array.from(array);
+    arrayShuffleInPlace(copy);
+    if (!arrayIsEqual(array, copy))
+      return copy;
+  }
+  return array;
+}
+chunkC66X5FP6_cjs.__name(arrayShuffleForce, "arrayShuffleForce");
+function arrayRandomElement(array) {
+  return array[Math.floor(getSecureRandomIfPossible() * array.length)];
+}
+chunkC66X5FP6_cjs.__name(arrayRandomElement, "arrayRandomElement");
+function arrayMax(...array) {
+  return arrayFlatten(array).reduce(
+    (acc, value) => acc != null ? value > acc ? value : acc : value,
+    void 0
+  );
+}
+chunkC66X5FP6_cjs.__name(arrayMax, "arrayMax");
+function arrayMin(...array) {
+  return arrayFlatten(array).reduce(
+    (acc, value) => acc != null ? value < acc ? value : acc : value,
+    void 0
+  );
+}
+chunkC66X5FP6_cjs.__name(arrayMin, "arrayMin");
+function arraySum(...array) {
+  return arrayFlatten(array).reduce((acc, value) => acc + value, 0);
+}
+chunkC66X5FP6_cjs.__name(arraySum, "arraySum");
+function arrayAvg(...array) {
+  let flatArray = arrayFlatten(array);
+  return flatArray.reduce((acc, value) => acc + value, 0) / flatArray.length;
+}
+chunkC66X5FP6_cjs.__name(arrayAvg, "arrayAvg");
+function arrayBatches(array, chunckLength) {
+  let chunks = [];
+  let i = 0;
+  const n = array.length;
+  while (i < n) {
+    chunks.push(array.slice(i, i += chunckLength));
+  }
+  return chunks;
+}
+chunkC66X5FP6_cjs.__name(arrayBatches, "arrayBatches");
+function createArray(size2 = 0, item) {
+  if (size2 <= 0)
+    return [];
+  let arr = new Array(size2);
+  for (let i = 0; i < size2; i++) {
+    arr[i] = item instanceof Function ? item(i) : item;
+  }
+  return arr;
+}
+chunkC66X5FP6_cjs.__name(createArray, "createArray");
+
+// src/common/data/basex.ts
+var log2 = chunkC66X5FP6_cjs.Logger("zeed:basex");
+var alphabets = {
+  "2": "01",
+  "8": "01234567",
+  "11": "0123456789a",
+  "16": "0123456789abcdef",
+  "32": "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
+  "32-rfc": "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  "32-hex": "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  "32-zbase": "ybndrfg8ejkmcpqxot1uwisza345h769",
+  "36": "0123456789abcdefghijklmnopqrstuvwxyz",
+  "58": "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+  "62": "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  "64": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  "64-url": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+  "66": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~",
+  "85": "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"
+};
+function useBase(alphaOrBase) {
+  let ALPHABET;
+  if (typeof alphaOrBase === "string") {
+    ALPHABET = alphaOrBase;
+  } else {
+    ALPHABET = alphabets[String(alphaOrBase)];
+    if (ALPHABET == null)
+      throw new Error(`Unknown base ${alphaOrBase}`);
+  }
+  if (ALPHABET.length >= 255)
+    throw new TypeError("Alphabet too long");
+  const BASE_MAP = new Uint8Array(256);
+  for (let j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (let i = 0; i < ALPHABET.length; i++) {
+    const x = ALPHABET.charAt(i);
+    const xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255)
+      throw new TypeError(x + " is ambiguous");
+    BASE_MAP[xc] = i;
+  }
+  const BASE = ALPHABET.length;
+  const LEADER = ALPHABET.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256);
+  const iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source, padToLength = -1) {
+    let data = toUint8Array(source);
+    if (data.byteLength === 0)
+      return "";
+    let length = 0;
+    let pbegin = 0;
+    const pend = data.byteLength;
+    while (pbegin !== pend && data[pbegin] === 0)
+      pbegin++;
+    const size2 = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    const dataEncoded = new Uint8Array(size2);
+    while (pbegin !== pend) {
+      let carry = data[pbegin];
+      let i = 0;
+      for (let it1 = size2 - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+        carry += 256 * dataEncoded[it1] >>> 0;
+        dataEncoded[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        log2.warn("Non-zero carry", data, padToLength, i, size2);
+        throw new Error("Non-zero carry");
+      }
+      length = i;
+      pbegin++;
+    }
+    let it2 = size2 - length;
+    while (it2 !== size2 && dataEncoded[it2] === 0) {
+      it2++;
+    }
+    let str = "";
+    for (; it2 < size2; ++it2)
+      str += ALPHABET.charAt(dataEncoded[it2]);
+    if (padToLength > 0) {
+      return str.padStart(padToLength, LEADER);
+    }
+    return str;
+  }
+  chunkC66X5FP6_cjs.__name(encode, "encode");
+  function decode(source, padToLength = -1) {
+    if (typeof source !== "string")
+      throw new TypeError("Expected String");
+    if (source.length === 0)
+      return new Uint8Array();
+    source = source.replace(/\s+/gi, "");
+    let psz = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      psz++;
+    }
+    const size2 = (source.length - psz) * FACTOR + 1 >>> 0;
+    const dataDecoded = new Uint8Array(size2);
+    while (source[psz]) {
+      let carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255)
+        throw new Error(`Unsupported character "${source[psz]}"`);
+      let i = 0;
+      for (let it3 = size2 - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+        carry += BASE * dataDecoded[it3] >>> 0;
+        dataDecoded[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0)
+        throw new Error("Non-zero carry");
+      length = i;
+      psz++;
+    }
+    let it4 = size2 - length;
+    while (it4 !== size2 && dataDecoded[it4] === 0) {
+      it4++;
+    }
+    if (padToLength > 0) {
+      return new Uint8Array([
+        ...new Uint8Array(padToLength - dataDecoded.length + it4),
+        ...dataDecoded.slice(it4)
+      ]);
+    }
+    return dataDecoded.slice(it4);
+  }
+  chunkC66X5FP6_cjs.__name(decode, "decode");
+  return {
+    encode,
+    decode
+  };
+}
+chunkC66X5FP6_cjs.__name(useBase, "useBase");
+var { encode: encodeBase16, decode: decodeBase16 } = useBase(16);
+var { encode: encodeBase32, decode: decodeBase32 } = useBase(32);
+var { encode: encodeBase58, decode: decodeBase58 } = useBase(58);
+var { encode: encodeBase62, decode: decodeBase62 } = useBase(62);
+var { encode: encodeBase64, decode: decodeBase64 } = useBase(62);
+
+// src/common/data/camelcase.ts
+var toCamelCase = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((s) => {
+  if (s.length > 0) {
+    if (/^[A-Z0-9_\-\ ]*$/g.test(s)) {
+      s = s.toLowerCase();
+    }
+    s = s.replace(/^[-_\ ]+/gi, "").replace(/[-_\ ]+$/gi, "").replace(/[-_\ ]+([a-z0-9])/gi, ($0, $1) => $1.toUpperCase());
+    s = s[0].toLowerCase() + s.substring(1);
+  }
+  return s;
+}, "toCamelCase");
+function toCapitalize(s) {
+  return s.charAt(0).toUpperCase() + s.toLowerCase().slice(1);
+}
+chunkC66X5FP6_cjs.__name(toCapitalize, "toCapitalize");
+function toCapitalizeWords(s) {
+  return s.replace(/\w\S*/g, toCapitalize);
+}
+chunkC66X5FP6_cjs.__name(toCapitalizeWords, "toCapitalizeWords");
+function fromCamelCase(str, separator2 = "-") {
+  separator2 = typeof separator2 === "undefined" ? "_" : separator2;
+  return str.replace(/([a-z\d])([A-Z])/g, "$1" + separator2 + "$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1" + separator2 + "$2").toLowerCase();
+}
+chunkC66X5FP6_cjs.__name(fromCamelCase, "fromCamelCase");
+
+// src/common/data/json.ts
+function serializer(replacer, cycleReplacer) {
+  var stack = [], keys = [];
+  if (cycleReplacer == null)
+    cycleReplacer = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(function(key, value) {
+      if (stack[0] === value)
+        return "[Circular ~]";
+      return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+    }, "cycleReplacer");
+  return function(key, value) {
+    if (stack.length > 0) {
+      var thisPos = stack.indexOf(this);
+      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+      if (~stack.indexOf(value))
+        value = cycleReplacer == null ? void 0 : cycleReplacer.call(this, key, value);
+    } else
+      stack.push(value);
+    return replacer == null ? value : replacer.call(this, key, value);
+  };
+}
+chunkC66X5FP6_cjs.__name(serializer, "serializer");
+function jsonStringify(obj, replacer, spaces, cycleReplacer) {
+  return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
+}
+chunkC66X5FP6_cjs.__name(jsonStringify, "jsonStringify");
+
+// src/common/data/convert.ts
+var TRUE_VALUES_LIST = ["1", "true", "yes", "y", "on"];
+function stringToBoolean(value, defaultValue = false) {
+  if (value == null || typeof value !== "string")
+    return defaultValue;
+  return TRUE_VALUES_LIST.includes(String(value).trim().toLowerCase());
+}
+chunkC66X5FP6_cjs.__name(stringToBoolean, "stringToBoolean");
+function stringToInteger(value, defaultValue = 0) {
+  if (value == null || typeof value !== "string")
+    return defaultValue;
+  return _nullishCoalesce(parseInt(value.trim(), 10), () => ( defaultValue));
+}
+chunkC66X5FP6_cjs.__name(stringToInteger, "stringToInteger");
+function stringToFloat(value, defaultValue = 0) {
+  if (value == null || typeof value !== "string")
+    return defaultValue;
+  return _nullishCoalesce(parseFloat(value.trim()), () => ( defaultValue));
+}
+chunkC66X5FP6_cjs.__name(stringToFloat, "stringToFloat");
+function valueToBoolean(value, defaultValue = false) {
+  if (value == null)
+    return defaultValue;
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return value !== 0;
+  return TRUE_VALUES_LIST.includes(String(value).trim().toLowerCase());
+}
+chunkC66X5FP6_cjs.__name(valueToBoolean, "valueToBoolean");
+function valueToInteger(value, defaultValue = 0) {
+  if (value == null)
+    return defaultValue;
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  if (typeof value === "number")
+    return Math.floor(value);
+  return _nullishCoalesce(parseInt(String(value).trim(), 10), () => ( defaultValue));
+}
+chunkC66X5FP6_cjs.__name(valueToInteger, "valueToInteger");
+function valueToFloat(value, defaultValue = 0) {
+  if (value == null)
+    return defaultValue;
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  if (typeof value === "number")
+    return Math.floor(value);
+  return _nullishCoalesce(parseFloat(String(value).trim()), () => ( defaultValue));
+}
+chunkC66X5FP6_cjs.__name(valueToFloat, "valueToFloat");
+function valueToString(value, defaultValue = "") {
+  if (value == null)
+    return defaultValue;
+  return _nullishCoalesce(String(value), () => ( defaultValue));
+}
+chunkC66X5FP6_cjs.__name(valueToString, "valueToString");
+var toFloat = valueToFloat;
+var toInt = valueToInteger;
+var toString = valueToString;
+var toBool = valueToBoolean;
+function formatMessages(messages2, opt = {}) {
+  const { trace = true, pretty = true } = opt;
+  return messages2.map((obj) => {
+    if (obj && typeof obj === "object") {
+      if (pretty && (obj instanceof Uint8Array || obj instanceof ArrayBuffer)) {
+        return "\n" + Uint8ArrayToHexDump(obj) + "\n";
+      }
+      if (obj instanceof Error) {
+        if (!trace) {
+          return `${obj.name || "Error"}: ${obj.message}`;
+        }
+        return `${obj.name || "Error"}: ${obj.message}
+${obj.stack}`;
+      }
+      return pretty ? jsonStringify(obj, null, 2) : jsonStringify(obj);
+    }
+    return String(obj);
+  });
+}
+chunkC66X5FP6_cjs.__name(formatMessages, "formatMessages");
+function renderMessages(messages2, opt = {}) {
+  return formatMessages(messages2, opt).join(" ");
+}
+chunkC66X5FP6_cjs.__name(renderMessages, "renderMessages");
+function fixBrokenUth8String(brokenString) {
+  try {
+    return decodeURIComponent(escape(brokenString));
+  } catch (e) {
+  }
+  return brokenString;
+}
+chunkC66X5FP6_cjs.__name(fixBrokenUth8String, "fixBrokenUth8String");
+
+// src/common/data/currency.ts
+var defaults = {
+  symbol: "$",
+  separator: ",",
+  decimal: ".",
+  errorOnInvalid: false,
+  precision: 2,
+  pattern: "!#",
+  negativePattern: "-!#",
+  format,
+  fromCents: false
+};
+var round = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((v) => Math.round(v), "round");
+var pow = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((p) => Math.pow(10, p), "pow");
+var rounding = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value, increment) => round(value / increment) * increment, "rounding");
+var groupRegex = /(\d)(?=(\d{3})+\b)/g;
+var vedicRegex = /(\d)(?=(\d\d)+\d\b)/g;
+function currency(value, opts = {}) {
+  return new Currency(value, opts);
+}
+chunkC66X5FP6_cjs.__name(currency, "currency");
+var _Currency = class {
+  constructor(value, opts = {}) {
+    let settings = Object.assign({}, defaults, opts);
+    let precision = pow(_nullishCoalesce(settings.precision, () => ( 2)));
+    let v = parse(value, settings);
+    this.intValue = v;
+    this.value = v / precision;
+    settings.increment = settings.increment || 1 / precision;
+    if (settings.useVedic) {
+      settings.groups = vedicRegex;
+    } else {
+      settings.groups = groupRegex;
+    }
+    this._settings = settings;
+    this._precision = precision;
+  }
+  add(number) {
+    let { intValue, _settings, _precision } = this;
+    return currency(
+      (intValue += parse(number, _settings)) / (_settings.fromCents ? 1 : _precision),
+      _settings
+    );
+  }
+  subtract(number) {
+    let { intValue, _settings, _precision } = this;
+    return currency(
+      (intValue -= parse(number, _settings)) / (_settings.fromCents ? 1 : _precision),
+      _settings
+    );
+  }
+  multiply(number) {
+    let { intValue, _settings, _precision } = this;
+    return currency(
+      (intValue *= number) / (_settings.fromCents ? 1 : pow(_precision)),
+      _settings
+    );
+  }
+  divide(number) {
+    let { intValue, _settings } = this;
+    return currency(intValue /= parse(number, _settings, false), _settings);
+  }
+  distribute(count) {
+    let { intValue, _precision, _settings } = this, distribution = [], split = Math[intValue >= 0 ? "floor" : "ceil"](intValue / count), pennies = Math.abs(intValue - split * count), precision = _settings.fromCents ? 1 : _precision;
+    for (; count !== 0; count--) {
+      let item = currency(split / precision, _settings);
+      pennies-- > 0 && (item = item[intValue >= 0 ? "add" : "subtract"](1 / precision));
+      distribution.push(item);
+    }
+    return distribution;
+  }
+  dollars() {
+    return ~~this.value;
+  }
+  cents() {
+    let { intValue, _precision } = this;
+    return ~~(intValue % _precision);
+  }
+  format(options) {
+    let { _settings } = this;
+    if (typeof options === "function") {
+      return options(this, _settings);
+    }
+    return _settings.format(this, Object.assign({}, _settings, options));
+  }
+  toString() {
+    let { intValue, _precision, _settings } = this;
+    return rounding(intValue / _precision, _settings.increment).toFixed(
+      _settings.precision
+    );
+  }
+  toJSON() {
+    return this.value;
+  }
+  static sum(...array) {
+    return arrayFlatten(array).reduce(
+      (acc, value) => currency(acc).add(value),
+      this.zero
+    );
+  }
+  static avg(...array) {
+    let arr = arrayFlatten(array);
+    return arr.reduce((acc, value) => currency(acc).add(value), this.zero).divide(arr.length);
+  }
+};
+var Currency = _Currency;
+chunkC66X5FP6_cjs.__name(Currency, "Currency");
+Currency.zero = new _Currency(0);
+Currency.one = new _Currency(1);
+Currency.hundred = new _Currency(100);
+function parse(value, opts, useRounding = true) {
+  let v = 0, { decimal: decimal2, errorOnInvalid, precision: decimals, fromCents } = opts, precision = pow(decimals), isNumber = typeof value === "number";
+  if (value instanceof Currency && fromCents) {
+    return value.intValue;
+  }
+  if (isNumber || value instanceof Currency) {
+    v = value instanceof Currency ? value.value : value;
+  } else if (typeof value === "string") {
+    let regex = new RegExp("[^-\\d" + decimal2 + "]", "g"), decimalString = new RegExp("\\" + decimal2, "g");
+    v = value.replace(/\((.*)\)/, "-$1").replace(regex, "").replace(decimalString, ".");
+    v = v || 0;
+  } else {
+    if (errorOnInvalid) {
+      throw Error("Invalid Input");
+    }
+    v = 0;
+  }
+  if (!fromCents) {
+    v *= precision;
+    v = v.toFixed(4);
+  }
+  return useRounding ? round(v) : v;
+}
+chunkC66X5FP6_cjs.__name(parse, "parse");
+function format(currency2, settings) {
+  let { pattern: pattern2, negativePattern, symbol, separator: separator2, decimal: decimal2, groups } = settings, split = ("" + currency2).replace(/^-/, "").split("."), dollars = split[0], cents = split[1];
+  return (currency2.value >= 0 ? pattern2 : negativePattern).replace("!", symbol).replace(
+    "#",
+    dollars.replace(groups, "$1" + separator2) + (cents ? decimal2 + cents : "")
+  );
+}
+chunkC66X5FP6_cjs.__name(format, "format");
+
+// src/common/data/day.ts
+var DAY_MS = 864e5;
+function dayYear(day2) {
+  return Math.floor(day2 / 1e4);
+}
+chunkC66X5FP6_cjs.__name(dayYear, "dayYear");
+function dayMonth(day2) {
+  return Math.floor(day2 / 100 % 100);
+}
+chunkC66X5FP6_cjs.__name(dayMonth, "dayMonth");
+function dayDay(day2) {
+  return Math.floor(day2 % 100);
+}
+chunkC66X5FP6_cjs.__name(dayDay, "dayDay");
+function dayToParts(day2) {
+  return [dayYear(day2), dayMonth(day2), dayDay(day2)];
+}
+chunkC66X5FP6_cjs.__name(dayToParts, "dayToParts");
+function dayToDate(day2, gmt = false) {
+  return gmt ? new Date(`${dayToString(day2)}T00:00:00.000Z`) : new Date(
+    day2 / 1e4,
+    day2 / 100 % 100 - 1,
+    day2 % 100
+  );
+}
+chunkC66X5FP6_cjs.__name(dayToDate, "dayToDate");
+function dayFromToday() {
+  return dayFromDate(new Date());
+}
+chunkC66X5FP6_cjs.__name(dayFromToday, "dayFromToday");
+function dayFromAny(value, gmt = false) {
+  if (typeof value === "number") {
+    if (value < 100)
+      return;
+    return value;
+  } else if (typeof value === "string") {
+    return dayFromString(value);
+  } else if (Array.isArray(value) && value.length === 3) {
+    const [year, month, day2] = value;
+    return dayFromParts(year, month, day2);
+  } else if (value instanceof Date) {
+    return dayFromDate(value, gmt);
+  }
+}
+chunkC66X5FP6_cjs.__name(dayFromAny, "dayFromAny");
+function dayToDateGMT(day2) {
+  return dayToDate(day2, true);
+}
+chunkC66X5FP6_cjs.__name(dayToDateGMT, "dayToDateGMT");
+function dayFromDate(date, gmt = false) {
+  return gmt ? dayFromString(date.toISOString()) : date.getFullYear() * 1e4 + (date.getMonth() + 1) * 100 + date.getDate();
+}
+chunkC66X5FP6_cjs.__name(dayFromDate, "dayFromDate");
+function dayFromDateGMT(date) {
+  return dayFromDate(date, true);
+}
+chunkC66X5FP6_cjs.__name(dayFromDateGMT, "dayFromDateGMT");
+function dayToTimestamp(day2, gmt = true) {
+  return dayToDate(day2, gmt).getTime();
+}
+chunkC66X5FP6_cjs.__name(dayToTimestamp, "dayToTimestamp");
+function dayFromTimestamp(ms, gmt = true) {
+  return dayFromDate(new Date(ms), gmt);
+}
+chunkC66X5FP6_cjs.__name(dayFromTimestamp, "dayFromTimestamp");
+function dayToString(day2, sep = "-") {
+  let baseString = String(day2);
+  return baseString.slice(0, 4) + sep + baseString.slice(4, 6) + sep + baseString.slice(6, 8);
+}
+chunkC66X5FP6_cjs.__name(dayToString, "dayToString");
+function dayFromParts(year, month = 1, day2 = 1) {
+  if (month < 1 || month > 12 || day2 < 1 || day2 > 31)
+    return;
+  return year * 1e4 + month * 100 + day2;
+}
+chunkC66X5FP6_cjs.__name(dayFromParts, "dayFromParts");
+function dayFromString(value) {
+  const string = String(value).replace(/[^0-9]/g, "").slice(0, 8);
+  if (string.length === 8)
+    return +string;
+}
+chunkC66X5FP6_cjs.__name(dayFromString, "dayFromString");
+function dayMonthStart(day2, offset = 0) {
+  let year = dayYear(day2);
+  let month = dayMonth(day2);
+  if (offset !== 0) {
+    month += offset;
+    year += Math.floor((month - 1) / 12);
+    month = Math.floor((month - 1) % 12) + 1;
+    if (month === 0)
+      month = 12;
+  }
+  return dayFromParts(year, month, 1);
+}
+chunkC66X5FP6_cjs.__name(dayMonthStart, "dayMonthStart");
+function dayYearStart(day2, offset = 0) {
+  let year = dayYear(day2);
+  return dayFromParts(year + offset, 1, 1);
+}
+chunkC66X5FP6_cjs.__name(dayYearStart, "dayYearStart");
+function dayOffset(day2, offset) {
+  return dayFromTimestamp(dayToTimestamp(day2) + offset * DAY_MS);
+}
+chunkC66X5FP6_cjs.__name(dayOffset, "dayOffset");
+function dayDiff(left, right) {
+  return Math.round((dayToTimestamp(right) - dayToTimestamp(left)) / DAY_MS);
+}
+chunkC66X5FP6_cjs.__name(dayDiff, "dayDiff");
+
+// src/common/exec/promise.ts
+var { warn } = chunkC66X5FP6_cjs.Logger("zeed:promise");
+function createPromise() {
+  let resolve, reject;
+  let promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return [promise, resolve, reject];
+}
+chunkC66X5FP6_cjs.__name(createPromise, "createPromise");
+async function sleep(milliSeconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliSeconds));
+}
+chunkC66X5FP6_cjs.__name(sleep, "sleep");
+async function immediate() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+chunkC66X5FP6_cjs.__name(immediate, "immediate");
+var timeoutReached = Symbol("timeout");
+async function timeout(promise, milliSeconds, timeoutValue = timeoutReached) {
+  return new Promise(async (resolve, reject) => {
+    let done = false;
+    const timeout2 = setTimeout(() => {
+      done = true;
+      resolve(timeoutValue);
+    }, milliSeconds);
+    try {
+      let result = await promise;
+      clearTimeout(timeout2);
+      if (!done)
+        resolve(result);
+    } catch (err) {
+      clearTimeout(timeout2);
+      if (!done)
+        reject(err);
+    }
+  });
+}
+chunkC66X5FP6_cjs.__name(timeout, "timeout");
+var timoutError = new Error("Timeout reached");
+function isTimeout(value) {
+  return value === timeoutReached || value === timoutError;
+}
+chunkC66X5FP6_cjs.__name(isTimeout, "isTimeout");
+async function tryTimeout(promise, milliSeconds) {
+  if (milliSeconds <= 0) {
+    return await promise;
+  }
+  return new Promise(async (resolve, reject) => {
+    let done = false;
+    const timeout2 = setTimeout(() => {
+      done = true;
+      reject(timoutError);
+    }, milliSeconds);
+    try {
+      let result = await promise;
+      clearTimeout(timeout2);
+      if (!done)
+        resolve(result);
+    } catch (err) {
+      clearTimeout(timeout2);
+      if (!done)
+        reject(err);
+    }
+  });
+}
+chunkC66X5FP6_cjs.__name(tryTimeout, "tryTimeout");
+function waitOn(obj, event, timeoutMS = 1e3) {
+  return new Promise((resolve, reject) => {
+    let fn = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => {
+      if (timer) {
+        clearTimeout(timer);
+        done();
+        resolve(value);
+      }
+    }, "fn");
+    let done = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(() => {
+      timer = null;
+      if (obj.off) {
+        obj.off(event, fn);
+      } else if (obj.removeEventListener) {
+        obj.removeEventListener(event, fn);
+      } else {
+        warn("No remove listener method found for", obj, event);
+      }
+    }, "done");
+    let timer = setTimeout(() => {
+      done();
+      reject(new Error(`Did not response in time`));
+    }, timeoutMS);
+    if (obj.on) {
+      obj.on(event, fn);
+    } else if (obj.addEventListener) {
+      obj.addEventListener(event, fn);
+    } else {
+      warn("No listener method found for", obj);
+    }
+  });
+}
+chunkC66X5FP6_cjs.__name(waitOn, "waitOn");
+function isPromise(value) {
+  return Boolean(
+    value && (value instanceof Promise || typeof value.then === "function")
+  );
+}
+chunkC66X5FP6_cjs.__name(isPromise, "isPromise");
+function promisify(value) {
+  return Promise.resolve(value);
+}
+chunkC66X5FP6_cjs.__name(promisify, "promisify");
+
+// src/common/data/day-legacy.ts
+var Day = class {
+  get value() {
+    return this.days;
+  }
+  constructor(days) {
+    var _a;
+    if (typeof days === "number") {
+      this.days = days;
+      return;
+    }
+    if (days != null) {
+      days = (_a = Day.from(days)) == null ? void 0 : _a.days;
+    }
+    if (days == null) {
+      const date = new Date();
+      this.days = date.getFullYear() * 1e4 + (date.getMonth() + 1) * 100 + date.getDate();
+    } else {
+      this.days = days;
+    }
+  }
+  static fromNumber(n) {
+    return new Day(n);
+  }
+  static fromString(dateString) {
+    return Day.from(+dateString.replace(/[^0-9]/g, "").slice(0, 8));
+  }
+  static fromDate(date, gmt = false) {
+    return gmt ? Day.fromString(date.toISOString().substr(0, 10)) : Day.from(
+      date.getFullYear() * 1e4 + (date.getMonth() + 1) * 100 + date.getDate()
+    );
+  }
+  static fromDateGMT(date) {
+    return Day.fromDate(date, true);
+  }
+  static from(value, gmt = false) {
+    if (typeof value === "number") {
+      if (value < 100)
+        return;
+      return new Day(value);
+    } else if (typeof value === "string") {
+      return Day.fromString(value);
+    } else if (Array.isArray(value) && value.length === 3) {
+      const [year, month = 1, day2 = 1] = value;
+      if (month < 1 || month > 12 || day2 < 1 || day2 > 31)
+        return;
+      return new Day(year * 1e4 + month * 100 + day2);
+    } else if (value instanceof Date) {
+      return Day.fromDate(value, gmt);
+    } else if (value instanceof Day) {
+      return value;
+    }
+  }
+  toNumber() {
+    return this.days;
+  }
+  toJson() {
+    return this.days;
+  }
+  toString(sep = "-") {
+    let baseString = String(this.days);
+    return baseString.slice(0, 4) + sep + baseString.slice(4, 6) + sep + baseString.slice(6, 8);
+  }
+  toDate(gmt = false) {
+    return gmt ? new Date(`${this.toString()}T00:00:00.000Z`) : new Date(
+      this.days / 1e4,
+      this.days / 100 % 100 - 1,
+      this.days % 100
+    );
+  }
+  toDateGMT() {
+    return this.toDate(true);
+  }
+  get year() {
+    return Math.floor(this.days / 1e4);
+  }
+  get month() {
+    return Math.floor(this.days / 100 % 100);
+  }
+  get day() {
+    return Math.floor(this.days % 100);
+  }
+  dayOffset(offset) {
+    return Day.fromDateGMT(
+      new Date(this.toDateGMT().getTime() + offset * DAY_MS)
+    );
+  }
+  monthStart() {
+    return Day.from([this.year, this.month, 1]);
+  }
+  yearStart() {
+    return Day.from([this.year, 1, 1]);
+  }
+  monthOffset(offset) {
+    let m = this.month + offset;
+    let mm = Math.floor((m - 1) % 12) + 1;
+    if (mm === 0)
+      mm = 12;
+    let yy = Math.floor((m - 1) / 12);
+    return Day.from([this.year + yy, mm, this.day]);
+  }
+  daysUntil(otherDay) {
+    var _a;
+    return Math.round(
+      (((_a = new Day(otherDay)) == null ? void 0 : _a.toDateGMT().getTime()) - this.toDateGMT().getTime()) / DAY_MS
+    );
+  }
+  yesterday() {
+    return this.dayOffset(-1);
+  }
+  tomorrow() {
+    return this.dayOffset(1);
+  }
+};
+chunkC66X5FP6_cjs.__name(Day, "Day");
+async function forEachDay(from, to, handler) {
+  let start = Day.from(from);
+  let end = Day.from(to);
+  while (start && end && (start == null ? void 0 : start.days) <= (end == null ? void 0 : end.days)) {
+    let result = handler(start);
+    if (isPromise(result)) {
+      await result;
+    }
+    start = start.dayOffset(1);
+  }
+}
+chunkC66X5FP6_cjs.__name(forEachDay, "forEachDay");
+function today() {
+  return new Day();
+}
+chunkC66X5FP6_cjs.__name(today, "today");
+function day(days) {
+  return new Day(days);
+}
+chunkC66X5FP6_cjs.__name(day, "day");
+function dateStringToDays(dateString) {
+  return Day.fromDate(new Date(dateString)).days;
+}
+chunkC66X5FP6_cjs.__name(dateStringToDays, "dateStringToDays");
+
+// src/common/data/decimal.ts
+function decimal(value, decimalPlaces = 2) {
+  return +(+value).toFixed(decimalPlaces);
+}
+chunkC66X5FP6_cjs.__name(decimal, "decimal");
+function decimalFromCents(value, decimalPlaces = 2) {
+  return +(+value / Math.pow(10, decimalPlaces)).toFixed(decimalPlaces);
+}
+chunkC66X5FP6_cjs.__name(decimalFromCents, "decimalFromCents");
+function decimalToCents(value, decimalPlaces = 2) {
+  return Math.round(+value * Math.pow(10, decimalPlaces));
+}
+chunkC66X5FP6_cjs.__name(decimalToCents, "decimalToCents");
+function decimalCentsPart(value, decimalPlaces = 2) {
+  return decimalPlaces * (decimal(value, decimalPlaces) % 1);
+}
+chunkC66X5FP6_cjs.__name(decimalCentsPart, "decimalCentsPart");
+
+// src/common/data/html.ts
+var escapeHTML = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;").replace(/"/g, "&quot;"), "escapeHTML");
+var unescapeHTML = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((s) => s.replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&apos;/gi, "'").replace(/&amp;/gi, "&"), "unescapeHTML");
+
+// src/common/data/path.ts
+var MAX_FILENAME_LENGTH = 100;
+var reControlChars = /[\u0000-\u001F\u0080-\u009F]/g;
+var reRelativePath = /^\.+/;
+var reTrailingPeriods = /\.+$/;
+function filenameReservedRegex() {
+  return /[<>:"/\\|?*\u0000-\u001F]/g;
+}
+chunkC66X5FP6_cjs.__name(filenameReservedRegex, "filenameReservedRegex");
+function windowsReservedNameRegex() {
+  return /^(con|prn|aux|nul|com\d|lpt\d)$/i;
+}
+chunkC66X5FP6_cjs.__name(windowsReservedNameRegex, "windowsReservedNameRegex");
+function toValidFilename(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  const replacement = "_";
+  if (filenameReservedRegex().test(replacement) && reControlChars.test(replacement)) {
+    throw new Error(
+      "Replacement string cannot contain reserved filename characters"
+    );
+  }
+  string = string.replace(filenameReservedRegex(), replacement).replace(reControlChars, replacement).replace(reRelativePath, replacement).replace(reTrailingPeriods, "");
+  string = windowsReservedNameRegex().test(string) ? string + replacement : string;
+  return string.slice(0, MAX_FILENAME_LENGTH);
+}
+chunkC66X5FP6_cjs.__name(toValidFilename, "toValidFilename");
+
+// src/common/data/regexp.ts
+var rxEscape = /[\\\-\[\]\/{}()*+?.^$|]/g;
+function escapeRegExp(value) {
+  if (!value)
+    return "";
+  if (value instanceof RegExp) {
+    return value.source;
+  }
+  return value.replace(rxEscape, "\\$&");
+}
+chunkC66X5FP6_cjs.__name(escapeRegExp, "escapeRegExp");
+
+// src/common/data/rounding.ts
+var isHalf = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => Math.abs(value) % 1 === 0.5, "isHalf");
+var isEven = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => value % 2 === 0, "isEven");
+var roundUp = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => Math.ceil(value), "roundUp");
+var roundDown = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => Math.floor(value), "roundDown");
+var roundHalfUp = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => Math.round(value), "roundHalfUp");
+var roundHalfOdd = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => {
+  const rounded = Math.round(value);
+  if (!isHalf(value)) {
+    return rounded;
+  }
+  return isEven(rounded) ? rounded - 1 : rounded;
+}, "roundHalfOdd");
+var roundHalfAwayFromZero = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => {
+  return isHalf(value) ? Math.sign(value) * Math.ceil(Math.abs(value)) : Math.round(value);
+}, "roundHalfAwayFromZero");
+var roundHalfDown = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => isHalf(value) ? Math.floor(value) : Math.round(value), "roundHalfDown");
+var roundHalfEven = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => {
+  const rounded = Math.round(value);
+  if (!isHalf(value)) {
+    return rounded;
+  }
+  return isEven(rounded) ? rounded : rounded - 1;
+}, "roundHalfEven");
+var roundHalfTowardsZero = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((value) => isHalf(value) ? Math.sign(value) * Math.floor(Math.abs(value)) : Math.round(value), "roundHalfTowardsZero");
+
+// src/common/data/sortable.ts
+function startSortWeight(items) {
+  return items.reduce((acc, item) => Math.min(acc, item.sort_weight || 0), 0) - 1 - getSecureRandomIfPossible();
+}
+chunkC66X5FP6_cjs.__name(startSortWeight, "startSortWeight");
+function endSortWeight(items) {
+  return items.reduce((acc, item) => Math.max(acc, item.sort_weight || 0), 0) + 1 + getSecureRandomIfPossible();
+}
+chunkC66X5FP6_cjs.__name(endSortWeight, "endSortWeight");
+function moveSortWeight(newIndex, oldIndex, items) {
+  let count = items.length;
+  const moveLower = newIndex < oldIndex;
+  if (count <= 0 || newIndex >= count - 1) {
+    return endSortWeight(items);
+  }
+  if (newIndex <= 0) {
+    return startSortWeight(items);
+  }
+  items = sortedItems([...items]);
+  const step = moveLower ? -1 : 0;
+  const lower = items[newIndex + step].sort_weight || 0;
+  const upper = items[newIndex + step + 1].sort_weight || 0;
+  const distance = upper - lower;
+  if (distance === 0) {
+    if (moveLower) {
+      return startSortWeight(items);
+    }
+    return endSortWeight(items);
+  }
+  const middle = lower + distance / 2;
+  const fuzzy = distance * 0.01 * (getSecureRandomIfPossible() - 0.5);
+  return middle + fuzzy;
+}
+chunkC66X5FP6_cjs.__name(moveSortWeight, "moveSortWeight");
+function sortedItems(items) {
+  items.sort((a, b) => (a.sort_weight || 0) - (b.sort_weight || 0));
+  return items;
+}
+chunkC66X5FP6_cjs.__name(sortedItems, "sortedItems");
+
+// src/common/data/url.ts
+var findURL = /((?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\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][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?)/gim;
+function linkifyPlainText(text) {
+  return text.split(findURL).map((part, i) => {
+    const escapedPart = escapeHTML(part);
+    return i % 2 ? `<a target="_blank" href="${escapedPart}">${toHumanReadableUrl(
+      escapedPart
+    )}</a>` : escapedPart;
+  }).join("");
+}
+chunkC66X5FP6_cjs.__name(linkifyPlainText, "linkifyPlainText");
+function toHumanReadableUrl(url) {
+  return url.replace(/^https?:\/\/(www\.)?/, "").replace(/\/$/, "");
+}
+chunkC66X5FP6_cjs.__name(toHumanReadableUrl, "toHumanReadableUrl");
+function encodeQuery(data) {
+  let pairs = [];
+  for (let [key, value] of Object.entries(data)) {
+    if (value != null) {
+      if (!Array.isArray(value)) {
+        value = [value];
+      }
+      for (let v of value) {
+        if (v != null) {
+          pairs.push(
+            encodeURIComponent(key) + "=" + encodeURIComponent(String(v))
+          );
+        }
+      }
+    }
+  }
+  return pairs.join("&");
+}
+chunkC66X5FP6_cjs.__name(encodeQuery, "encodeQuery");
+function parseQuery(queryString) {
+  let query = {};
+  let pairs = (queryString[0] === "?" ? queryString.substr(1) : queryString).split("&");
+  for (let i = 0; i < pairs.length; i++) {
+    let pair = pairs[i].split("=");
+    let key = decodeURIComponent(pair[0]);
+    let value = decodeURIComponent(pair[1] || "");
+    if (query[key] != null) {
+      if (!Array.isArray(query[key])) {
+        query[key] = [query[key]];
+      }
+      query[key].push(value);
+    } else {
+      query[key] = value;
+    }
+  }
+  return query;
+}
+chunkC66X5FP6_cjs.__name(parseQuery, "parseQuery");
+
+// src/common/data/utils.ts
+function ensureKey(obj, key, createFn) {
+  let value = obj[key];
+  if (value === void 0) {
+    value = createFn(key, obj);
+    obj[key] = value;
+  }
+  return value;
+}
+chunkC66X5FP6_cjs.__name(ensureKey, "ensureKey");
+async function ensureKeyAsync(obj, key, createFn) {
+  let value = obj[key];
+  if (value === void 0) {
+    value = await createFn(key, obj);
+    obj[key] = value;
+  }
+  return value;
+}
+chunkC66X5FP6_cjs.__name(ensureKeyAsync, "ensureKeyAsync");
+function size(obj) {
+  if (obj != null) {
+    if (obj.size != null) {
+      return obj.size;
+    }
+    if (obj.length != null) {
+      return obj.length;
+    }
+    return Object.keys(obj).length;
+  }
+  return 0;
+}
+chunkC66X5FP6_cjs.__name(size, "size");
+function last(array) {
+  return array != null && array.length > 0 ? array[array.length - 1] : void 0;
+}
+chunkC66X5FP6_cjs.__name(last, "last");
+function empty(value) {
+  try {
+    if (value != null) {
+      if (Array.isArray(value)) {
+        return value.length <= 0;
+      } else if (typeof value === "string") {
+        return value.length <= 0;
+      } else if ((value == null ? void 0 : value.size) != null) {
+        return value.size <= 0;
+      } else {
+        return Object.keys(value).length <= 0;
+      }
+    }
+  } catch (err) {
+    console.warn("Failed to check if empty for", value, err);
+  }
+  return true;
+}
+chunkC66X5FP6_cjs.__name(empty, "empty");
+function cloneObject(obj) {
+  if (Object(obj) !== obj)
+    return obj;
+  return JSON.parse(JSON.stringify(obj));
+}
+chunkC66X5FP6_cjs.__name(cloneObject, "cloneObject");
+function cloneJsonObject(obj) {
+  if (Object(obj) !== obj)
+    return obj;
+  return JSON.parse(JSON.stringify(obj));
+}
+chunkC66X5FP6_cjs.__name(cloneJsonObject, "cloneJsonObject");
+function memoize(fn) {
+  let cache = /* @__PURE__ */ new Map();
+  return (n) => {
+    if (cache.has(n)) {
+      return cache.get(n);
+    }
+    let result = fn(n);
+    cache.set(n, result);
+    return result;
+  };
+}
+chunkC66X5FP6_cjs.__name(memoize, "memoize");
+function forTimes(count, fn) {
+  let result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(fn(i, count));
+  }
+  return result;
+}
+chunkC66X5FP6_cjs.__name(forTimes, "forTimes");
+
+// src/common/data/xrx.ts
+var RX_WHITESPACE = /\\\s|\s+|#[^\n]*\n?/gm;
+var RX_REAL_GROUPS = /\(\?P?<(\w[\w\d_]+)>|\((?!\?(:|\!|=|<=|<\!))/gm;
+var RX_LOOK_BEHIND = /^((?:\(\?[\w$]+\))?)\(\?<([=!])([\s\S]*?)\)/gm;
+var log3 = chunkC66X5FP6_cjs.Logger("xrx");
+function regExpString(rx) {
+  return typeof rx === "string" ? rx : rx.source || "";
+}
+chunkC66X5FP6_cjs.__name(regExpString, "regExpString");
+function regExpEscape(str) {
+  return str.replace(/[-\[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+chunkC66X5FP6_cjs.__name(regExpEscape, "regExpEscape");
+var XRX = class {
+  constructor(pattern2, flags) {
+    this.namedGroups = {};
+    this.names = [];
+    let _flags = _nullishCoalesce(flags, () => ( ""));
+    let _rx;
+    if (pattern2 instanceof RegExp) {
+      if (flags == null) {
+        _flags = pattern2.flags;
+      }
+      _rx = pattern2.source;
+    } else {
+      _rx = pattern2;
+    }
+    const extended = _flags && _flags.indexOf("x") !== -1;
+    if (extended) {
+      _flags = _flags.replace("x", "");
+      _rx = _rx.replace(RX_WHITESPACE, (r) => {
+        return r[0] === "\\" ? r : "";
+      });
+    }
+    if (!(pattern2 instanceof RegExp)) {
+      let index = 0;
+      _rx = _rx.replace(RX_REAL_GROUPS, (str, name) => {
+        index += 1;
+        if (name) {
+          if (name !== "index" && name !== "length" && !this.namedGroups[name]) {
+            this.namedGroups[name] = index;
+          } else {
+            log3.error(`Unallowed or duplicate group name: ${name}`);
+          }
+          return "(";
+        }
+        return str;
+      });
+      this.names = Object.keys(this.namedGroups);
+    }
+    _rx = regExpString(_rx);
+    RX_LOOK_BEHIND.lastIndex = 0;
+    let parts = RX_LOOK_BEHIND.exec(_rx);
+    if (parts) {
+      this.lookBehind = {
+        rx: new RegExp(`${parts[3]}$(?!\\s)`),
+        expect: parts ? parts[2] === "=" : !parts
+      };
+      _rx = _rx.substr(parts[0].length);
+    }
+    this.rx = new RegExp(_rx, _flags);
+  }
+  get lastIndex() {
+    return this.rx.lastIndex;
+  }
+  set lastIndex(index) {
+    this.rx.lastIndex = index;
+  }
+  _handleMatch(m) {
+    if (this.lookBehind) {
+      let leftContext = m.input.slice(0, m.index);
+      if (this.lookBehind.expect !== this.lookBehind.rx.test(leftContext)) {
+        return null;
+      }
+    }
+    for (let name of this.names) {
+      m[name] = m[this.namedGroups[name]];
+    }
+    return m;
+  }
+  exec(str) {
+    let m;
+    while (m = this.rx.exec(str)) {
+      if (this.rx.lastIndex === m.index) {
+        this.rx.lastIndex++;
+      }
+      m = this._handleMatch(m);
+      if (m != null) {
+        return m;
+      }
+    }
+  }
+  execAll(str) {
+    let matches = [];
+    let m;
+    this.rx.lastIndex = 0;
+    while (m = this.exec(str)) {
+      matches.push(m);
+    }
+    this.rx.lastIndex = 0;
+    return matches;
+  }
+  replace(str, replacement) {
+    let fn = typeof replacement === "function" ? replacement : () => replacement;
+    return str.replace(this.rx, (m) => {
+      return fn(m);
+    });
+  }
+};
+chunkC66X5FP6_cjs.__name(XRX, "XRX");
+
+// src/common/dispose-defer.ts
+var log4 = chunkC66X5FP6_cjs.Logger("dispose");
+async function callDisposer(disposable) {
+  if (typeof disposable === "function") {
+    await promisify(disposable());
+  } else if (isPromise(disposable)) {
+    await disposable;
+  } else if (typeof disposable.dispose === "function") {
+    await promisify(disposable.dispose());
+  } else if (isPromise(disposable.dispose)) {
+    await disposable.dispose;
+  } else if (typeof disposable.cleanup === "function") {
+    await promisify(disposable.cleanup());
+  } else if (isPromise(disposable.cleanup)) {
+    await disposable.cleanup;
+  }
+}
+chunkC66X5FP6_cjs.__name(callDisposer, "callDisposer");
+function useDispose(config) {
+  const { name } = typeof config === "string" ? { name: config } : _nullishCoalesce(config, () => ( {}));
+  let tracked = [];
+  const untrack = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async (disposable) => {
+    if (disposable != null && tracked.includes(disposable)) {
+      arrayFilterInPlace(tracked, (el) => el !== disposable);
+      await callDisposer(disposable);
+    }
+  }, "untrack");
+  const dispose = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async () => {
+    if (name)
+      log4.debug(`dispose ${name}: ${tracked.length} entries`);
+    while (tracked.length > 0) {
+      await untrack(tracked[0]);
+    }
+  }, "dispose");
+  const track = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((obj) => {
+    if (obj == null)
+      return;
+    tracked.unshift(obj);
+    return () => untrack(obj);
+  }, "track");
+  return Object.assign(dispose, {
+    track,
+    add: track,
+    untrack,
+    dispose,
+    exec: dispose,
+    getSize() {
+      return tracked.length;
+    }
+  });
+}
+chunkC66X5FP6_cjs.__name(useDispose, "useDispose");
+var useDisposer = useDispose;
+function useDefer(config = {}) {
+  const { mode = "fifo" } = config;
+  let steps = [];
+  const exec = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async (expectSync = false) => {
+    while (steps.length > 0) {
+      let step = steps[0];
+      arrayFilterInPlace(steps, (el) => el !== step);
+      if (typeof step === "function") {
+        let result = step();
+        if (isPromise(result)) {
+          if (expectSync)
+            throw new Error(
+              `Expected sync only function, but found async: ${step}`
+            );
+          await result;
+        }
+      } else if (isPromise(step)) {
+        if (expectSync)
+          throw new Error(
+            `Expected sync only function, but found async: ${step}`
+          );
+        await step;
+      } else {
+        throw new Error(`Unhandled disposable: ${step}`);
+      }
+    }
+  }, "exec");
+  const add = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((obj) => {
+    if (mode === "lifo") {
+      steps.unshift(obj);
+    } else {
+      steps.push(obj);
+    }
+  }, "add");
+  return Object.assign(exec, {
+    add,
+    exec,
+    getSize() {
+      return steps.length;
+    }
+  });
+}
+chunkC66X5FP6_cjs.__name(useDefer, "useDefer");
+function useTimeout(fn, timeout2 = 0) {
+  let timeoutHandle = setTimeout(fn, timeout2);
+  return () => {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = void 0;
+    }
+  };
+}
+chunkC66X5FP6_cjs.__name(useTimeout, "useTimeout");
+function useInterval(fn, interval) {
+  let intervalHandle = setInterval(fn, interval);
+  return () => {
+    if (intervalHandle) {
+      clearInterval(intervalHandle);
+      intervalHandle = void 0;
+    }
+  };
+}
+chunkC66X5FP6_cjs.__name(useInterval, "useInterval");
+function useEventListener(emitter, eventName, fn, ...args) {
+  if (emitter == null)
+    return () => {
+    };
+  if (emitter.on) {
+    emitter.on(eventName, fn, ...args);
+  } else if (emitter.addEventListener) {
+    emitter.addEventListener(eventName, fn, ...args);
+  }
+  return () => {
+    if (emitter.off) {
+      emitter.off(eventName, fn, ...args);
+    } else if (emitter.removeEventListener) {
+      emitter.removeEventListener(eventName, fn, ...args);
+    }
+  };
+}
+chunkC66X5FP6_cjs.__name(useEventListener, "useEventListener");
+
+// src/common/exec/mutex.ts
+function useMutex() {
+  let token = true;
+  return (fn, elseFn) => {
+    let executed = false;
+    if (token) {
+      token = false;
+      try {
+        fn();
+        executed = true;
+      } finally {
+        token = true;
+      }
+    } else if (elseFn !== void 0) {
+      elseFn();
+    }
+    return executed;
+  };
+}
+chunkC66X5FP6_cjs.__name(useMutex, "useMutex");
+function useAsyncMutex() {
+  let token = true;
+  return async (fn, elseFn) => {
+    let executed = false;
+    if (token) {
+      token = false;
+      try {
+        let result = fn();
+        if (isPromise(result))
+          await result;
+        executed = true;
+      } finally {
+        token = true;
+      }
+    } else if (elseFn !== void 0) {
+      let result = elseFn();
+      if (isPromise(result))
+        await result;
+    }
+    return executed;
+  };
+}
+chunkC66X5FP6_cjs.__name(useAsyncMutex, "useAsyncMutex");
+
+// src/common/msg/emitter.ts
+var log5 = chunkC66X5FP6_cjs.Logger("zeed:emitter");
+var Emitter = class {
+  constructor() {
+    this.subscribers = {};
+    this.subscribersOnAny = [];
+    this.dispose = useDispose();
+    this.call = new Proxy({}, {
+      get: (target, name) => (...args) => this.emit(name, ...args)
+    });
+  }
+  async emit(event, ...args) {
+    let ok = false;
+    this.dispose.add(() => {
+      this.subscribers = {};
+      this.subscribersOnAny = [];
+    });
+    try {
+      let subscribers = this.subscribers[event] || [];
+      this.subscribersOnAny.forEach((fn) => fn(event, ...args));
+      if (subscribers.length > 0) {
+        let all = subscribers.map((fn) => {
+          try {
+            return promisify(fn(...args));
+          } catch (err) {
+            log5.warn("emit warning:", err);
+          }
+        });
+        ok = true;
+        await Promise.all(all);
+      }
+    } catch (err) {
+      log5.error("emit exception", err);
+    }
+    return ok;
+  }
+  onAny(fn) {
+    this.subscribersOnAny.push(fn);
+  }
+  on(event, listener) {
+    let subscribers = this.subscribers[event] || [];
+    subscribers.push(listener);
+    this.subscribers[event] = subscribers;
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  onCall(handlers) {
+    for (const [name, handler] of Object.entries(handlers)) {
+      this.on(name, handler);
+    }
+  }
+  once(event, listener) {
+    const onceListener = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async (...args) => {
+      this.off(event, onceListener);
+      return await promisify(listener(...args));
+    }, "onceListener");
+    this.on(event, onceListener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  off(event, listener) {
+    this.subscribers[event] = (this.subscribers[event] || []).filter(
+      (f) => listener && f !== listener
+    );
+    return this;
+  }
+  removeAllListeners() {
+    this.subscribers = {};
+    return this;
+  }
+};
+chunkC66X5FP6_cjs.__name(Emitter, "Emitter");
+function getGlobalEmitter() {
+  let emitter = chunkC66X5FP6_cjs.getGlobalContext().emitter;
+  if (!emitter) {
+    emitter = new Emitter();
+    chunkC66X5FP6_cjs.getGlobalContext().emitter = emitter;
+  }
+  return emitter;
+}
+chunkC66X5FP6_cjs.__name(getGlobalEmitter, "getGlobalEmitter");
+var messages = new Emitter();
+function lazyListener(emitter, listenerKey) {
+  const name = Math.round(getSecureRandomIfPossible() * 100);
+  var events = [];
+  var lazyResolve;
+  const incoming = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((key, obj) => {
+    let ev = { key, obj };
+    events.push(ev);
+    lazyResolve && lazyResolve();
+  }, "incoming");
+  if (listenerKey) {
+    if (emitter.on) {
+      emitter.on(listenerKey, (obj) => {
+        incoming(listenerKey, obj);
+      });
+    } else if (emitter.addEventListener) {
+      emitter.addEventListener(listenerKey, (obj) => {
+        incoming(listenerKey, obj);
+      });
+    } else {
+      log5.error(name, "Cannot listen to key");
+    }
+  } else {
+    if (emitter.onAny) {
+      emitter.onAny((key, obj) => {
+        incoming(key, obj);
+      });
+    } else {
+      log5.error(name, "cannot listen to all for", emitter);
+    }
+  }
+  let on = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((key, skipUnmatched = true) => {
+    return new Promise((resolve, reject) => {
+      if (!key) {
+        key = listenerKey;
+        if (!key) {
+          if (events.length) {
+            key = events[0].key;
+          }
+        }
+      }
+      lazyResolve = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(() => {
+        while (events.length > 0) {
+          let ev = events.shift();
+          if (ev.key === key) {
+            lazyResolve = void 0;
+            resolve(ev.obj);
+          } else {
+            if (skipUnmatched) {
+              log5.warn(name, `Unhandled event ${key} with value: ${ev.obj}`);
+              continue;
+            }
+            reject(`Expected ${key}, but found ${ev.key} with value=${ev.obj}`);
+            log5.error(name, `Unhandled event ${key} with value: ${ev.obj}`);
+          }
+          break;
+        }
+      }, "lazyResolve");
+      lazyResolve();
+    });
+  }, "on");
+  return on;
+}
+chunkC66X5FP6_cjs.__name(lazyListener, "lazyListener");
+
+// src/common/uuid.ts
+var { encode: encode62, decode: decode62 } = useBase(62);
+var { encode: encode32, decode: decode32 } = useBase(32);
+function uuidBytes() {
+  return randomUint8Array(16);
+}
+chunkC66X5FP6_cjs.__name(uuidBytes, "uuidBytes");
+var uuid32bit = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(() => new Uint32Array(randomUint8Array(4))[0], "uuid32bit");
+function uuid() {
+  return encode62(uuidBytes(), 22);
+}
+chunkC66X5FP6_cjs.__name(uuid, "uuid");
+function uuidEncode(bytes) {
+  return encode62(bytes, 22);
+}
+chunkC66X5FP6_cjs.__name(uuidEncode, "uuidEncode");
+function uuidDecode(uuid2) {
+  return decode62(uuid2, 16);
+}
+chunkC66X5FP6_cjs.__name(uuidDecode, "uuidDecode");
+function uuidB32() {
+  return encode32(uuidBytes(), 26);
+}
+chunkC66X5FP6_cjs.__name(uuidB32, "uuidB32");
+function uuid32Encode(bytes) {
+  return encode32(bytes, 26);
+}
+chunkC66X5FP6_cjs.__name(uuid32Encode, "uuid32Encode");
+function uuid32Decode(uuid2) {
+  return decode32(uuid2, 16);
+}
+chunkC66X5FP6_cjs.__name(uuid32Decode, "uuid32Decode");
+var _unameCounters = {};
+function uname(name = "id") {
+  if (_unameCounters[name] == null) {
+    _unameCounters[name] = 0;
+  }
+  return `${name}-${_unameCounters[name]++}`;
+}
+chunkC66X5FP6_cjs.__name(uname, "uname");
+var _qid = 0;
+function qid() {
+  return `id-${_qid++}`;
+}
+chunkC66X5FP6_cjs.__name(qid, "qid");
+var pattern = "10000000-1000-4000-8000-100000000000";
+var uuidv4 = typeof crypto !== "undefined" && crypto.randomUUID != null ? crypto.randomUUID : () => pattern.replace(
+  /[018]/g,
+  (c) => (c ^ randomUint8Array(1)[0] & 15 >> c / 4).toString(16)
+);
+var ReferenceDateInMS = 16e11;
+function longToByteArray(long) {
+  var byteArray = new Uint8Array([0, 0, 0, 0, 0, 0]);
+  const bytes = byteArray.length - 1;
+  for (var index = 0; index < byteArray.length; index++) {
+    var byte = long & 255;
+    byteArray[bytes - index] = byte;
+    long = (long - byte) / 256;
+  }
+  return byteArray;
+}
+chunkC66X5FP6_cjs.__name(longToByteArray, "longToByteArray");
+function suidBytes() {
+  const ms = chunkC66X5FP6_cjs.getTimestamp() - ReferenceDateInMS;
+  return new Uint8Array([...longToByteArray(ms), ...randomUint8Array(10)]);
+}
+chunkC66X5FP6_cjs.__name(suidBytes, "suidBytes");
+function suid() {
+  return encode62(suidBytes(), 22);
+}
+chunkC66X5FP6_cjs.__name(suid, "suid");
+function suidDate(id) {
+  return suidBytesDate(decode62(id, 16));
+}
+chunkC66X5FP6_cjs.__name(suidDate, "suidDate");
+function suidBytesDate(id) {
+  return new Date(
+    ReferenceDateInMS + id.slice(0, 6).reduce((acc, byte) => {
+      return acc * 256 + byte;
+    }, 0)
+  );
+}
+chunkC66X5FP6_cjs.__name(suidBytesDate, "suidBytesDate");
+
+// src/common/exec/pool.ts
+var PoolTaskState = /* @__PURE__ */ ((PoolTaskState2) => {
+  PoolTaskState2[PoolTaskState2["waiting"] = 0] = "waiting";
+  PoolTaskState2[PoolTaskState2["running"] = 1] = "running";
+  PoolTaskState2[PoolTaskState2["finished"] = 2] = "finished";
+  return PoolTaskState2;
+})(PoolTaskState || {});
+var PoolTaskIdConflictResolution = /* @__PURE__ */ ((PoolTaskIdConflictResolution2) => {
+  PoolTaskIdConflictResolution2[PoolTaskIdConflictResolution2["replace"] = 0] = "replace";
+  PoolTaskIdConflictResolution2[PoolTaskIdConflictResolution2["memoize"] = 1] = "memoize";
+  PoolTaskIdConflictResolution2[PoolTaskIdConflictResolution2["error"] = 2] = "error";
+  return PoolTaskIdConflictResolution2;
+})(PoolTaskIdConflictResolution || {});
+function usePool(config = {}) {
+  const { maxParallel = 3 } = config;
+  const events = new Emitter();
+  let countMax = 0;
+  let countResolved = 0;
+  let currentParallel = 0;
+  let priority = 0;
+  let tasks = {};
+  async function waitFinishAll() {
+    if (countMax > 0) {
+      const [promise, resolve] = createPromise();
+      events.once("didFinish", resolve);
+      return promise;
+    }
+  }
+  chunkC66X5FP6_cjs.__name(waitFinishAll, "waitFinishAll");
+  function didFinish() {
+    events.emit("didFinish");
+    countMax = 0;
+    countResolved = 0;
+  }
+  chunkC66X5FP6_cjs.__name(didFinish, "didFinish");
+  function didUpdate() {
+    let presentMax = 0;
+    let presentResolved = 0;
+    for (const { max, resolved, state } of Object.values(tasks)) {
+      presentMax += max;
+      presentResolved += state === 2 /* finished */ ? max : Math.min(max, resolved);
+    }
+    events.emit(
+      "didUpdate",
+      countMax,
+      countResolved,
+      presentMax,
+      presentResolved
+    );
+  }
+  chunkC66X5FP6_cjs.__name(didUpdate, "didUpdate");
+  function performNext() {
+    didUpdate();
+    if (countMax > 0 && countMax === countResolved)
+      didFinish();
+    if (currentParallel >= maxParallel)
+      return;
+    let waitingTasks = Object.values(tasks).filter(
+      (t) => t.state === 0 /* waiting */
+    );
+    if (waitingTasks.length > 0) {
+      let taskInfo;
+      for (let t of waitingTasks) {
+        if (taskInfo == null || t.priority < taskInfo.priority) {
+          taskInfo = t;
+        }
+      }
+      if (taskInfo != null) {
+        const id = taskInfo.id;
+        const done = taskInfo.done;
+        taskInfo.state = 1 /* running */;
+        ++currentParallel;
+        events.emit("didStart", id);
+        const taskFinished = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((result) => {
+          if (taskInfo) {
+            taskInfo.result = result;
+            taskInfo.state = 2 /* finished */;
+            taskInfo.resolved = taskInfo.max;
+          }
+          --currentParallel;
+          ++countResolved;
+          performNext();
+        }, "taskFinished");
+        taskInfo.task(taskInfo).then((r) => {
+          done(r);
+          events.emit("didResolve", id, r);
+          taskFinished(r);
+        }).catch((err) => {
+          done();
+          events.emit("didReject", id, err);
+          taskFinished();
+        });
+      }
+    }
+  }
+  chunkC66X5FP6_cjs.__name(performNext, "performNext");
+  function cancel(id) {
+    let taskInfo = tasks[id];
+    if (taskInfo && taskInfo.state === 0 /* waiting */) {
+      tasks[id].state = 2 /* finished */;
+      ++countResolved;
+      events.emit("didCancel", id);
+      didUpdate();
+    }
+  }
+  chunkC66X5FP6_cjs.__name(cancel, "cancel");
+  function cancelAll() {
+    Object.keys(tasks).forEach(cancel);
+  }
+  chunkC66X5FP6_cjs.__name(cancelAll, "cancelAll");
+  function enqueue(task, config2 = {}) {
+    let done;
+    let promise = new Promise((resolve) => done = resolve);
+    let id = _nullishCoalesce(config2.id, () => ( uuid()));
+    if (tasks[id] != null) {
+      const resolution = _nullishCoalesce(config2.idConflictResolution, () => ( 1)) /* memoize */;
+      if (resolution === 0 /* replace */) {
+        cancel(id);
+      } else if (resolution === 1 /* memoize */) {
+        let runningTask = tasks[id];
+        return {
+          id,
+          promise: (async () => {
+            if (runningTask.state === 2 /* finished */) {
+              return tasks[id].result;
+            }
+          })(),
+          dispose: () => cancel(id),
+          cancel: () => cancel(id)
+        };
+      } else {
+        throw new Error(`Pool task with id=${id} already exists!`);
+      }
+    }
+    tasks[id] = {
+      id,
+      task,
+      priority: ++priority,
+      state: 0 /* waiting */,
+      max: _nullishCoalesce(config2.max, () => ( 1)),
+      resolved: _nullishCoalesce(config2.resolved, () => ( 0)),
+      done,
+      payload: config2.payload,
+      setMax(max) {
+        tasks[id].max = max;
+        didUpdate();
+      },
+      setResolved(max) {
+        tasks[id].resolved = max;
+        didUpdate();
+      },
+      incResolved(inc = 1) {
+        tasks[id].resolved += inc;
+        didUpdate();
+      }
+    };
+    ++countMax;
+    performNext();
+    return {
+      id,
+      promise,
+      dispose: () => cancel(id),
+      cancel: () => cancel(id)
+    };
+  }
+  chunkC66X5FP6_cjs.__name(enqueue, "enqueue");
+  return {
+    events,
+    cancel,
+    cancelAll,
+    enqueue,
+    dispose: cancelAll,
+    waitFinishAll
+  };
+}
+chunkC66X5FP6_cjs.__name(usePool, "usePool");
+
+// src/common/exec/queue.ts
+var SerialQueue = class extends Emitter {
+  constructor(opt = {}) {
+    super();
+    this.queue = [];
+    this.waitToFinish = [];
+    this.countMax = 0;
+    this.countResolved = 0;
+    this.paused = false;
+    const { name = uname("queue"), logLevel } = opt;
+    this.name = name;
+    this.log = chunkC66X5FP6_cjs.Logger(`zeed:queue:${name}`, _nullishCoalesce(logLevel, () => ( Infinity)) /* off */);
+  }
+  async performNext() {
+    this.log(`performNext, queue.length =`, this.queue.length);
+    if (this.currentTask != null) {
+      this.log(`performNext => skip while another task is running`);
+      return;
+    }
+    if (this.paused) {
+      this.log(`performNext => skip while is paused`);
+      return;
+    }
+    while (this.currentTask == null && !this.paused) {
+      let info = this.queue.shift();
+      this.log(`performNext => ${info == null ? void 0 : info.name}`);
+      if (info == null) {
+        break;
+      }
+      if (this.countResolved === 0) {
+        this.emit("didStart", this.countMax);
+      }
+      const { name, task, resolve } = info;
+      this.currentTask = task();
+      let result = void 0;
+      try {
+        this.log.info(`start task ${name}`);
+        result = await this.currentTask;
+        this.log(`finished task ${name} with result =`, result);
+      } catch (err) {
+        this.log.warn("Error performing task", err);
+      }
+      resolve(result);
+      this.currentTask = void 0;
+      this.countResolved += 1;
+      this.emit("didUpdate", this.countMax, this.countResolved);
+    }
+    if (this.queue.length === 0) {
+      this.emit("didFinish");
+      this.countMax = 0;
+      this.countResolved = 0;
+    }
+    while (this.waitToFinish.length > 0) {
+      this.waitToFinish.shift()();
+    }
+  }
+  async enqueue(task, opt = {}) {
+    const { immediate: immediate2 = false, name = uname(this.name) } = opt;
+    if (immediate2) {
+      this.log.info(`immediate execution ${name}`);
+      return await task();
+    }
+    this.log(`enqueue ${name}`);
+    return new Promise((resolve) => {
+      this.queue.push({
+        name,
+        task,
+        resolve
+      });
+      this.countMax += 1;
+      this.emit("didUpdate", this.countMax, this.countResolved);
+      this.performNext();
+    });
+  }
+  async enqueueReentrant(task, opt = {}) {
+    return this.enqueue(task, {
+      immediate: this.currentTask != null,
+      name: opt.name
+    });
+  }
+  async cancelAll(unblock = true) {
+    this.log(`cancelAll`);
+    this.emit("didCancel");
+    let resolver = this.queue.map((task) => task.resolve);
+    this.queue = [];
+    resolver.forEach((r) => r(void 0));
+    await this.wait();
+  }
+  async pause() {
+    this.log(`pause`);
+    this.paused = true;
+    await this.wait();
+  }
+  resume() {
+    this.log(`resume`);
+    this.paused = false;
+    this.performNext();
+  }
+  async wait() {
+    this.log(`wait`);
+    if (this.currentTask == null && (this.queue.length === 0 || this.paused)) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.waitToFinish.push(resolve);
+    });
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  get hasTasks() {
+    return this.queue.length !== 0;
+  }
+};
+chunkC66X5FP6_cjs.__name(SerialQueue, "SerialQueue");
+var log6 = () => {
+};
+function throttle(callback, opt = {}) {
+  const { delay = 100, trailing = true, leading = true } = opt;
+  let timeoutID = 0;
+  let checkpoint = 0;
+  let visited = 0;
+  let trailingExec;
+  let debugCheckpoint = Date.now();
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+      timeoutID = void 0;
+    }
+  }
+  chunkC66X5FP6_cjs.__name(clearExistingTimeout, "clearExistingTimeout");
+  function wrapper(...args) {
+    const now = Date.now();
+    let self2 = this;
+    let elapsed = now - checkpoint;
+    function debugElapsed() {
+      const dnow = Date.now();
+      return `total ${(dnow - debugCheckpoint).toFixed(1)}ms - elapsed ${(dnow - checkpoint).toFixed(1)}ms - visited ${visited}x`;
+    }
+    chunkC66X5FP6_cjs.__name(debugElapsed, "debugElapsed");
+    function exec() {
+      visited = 0;
+      checkpoint = Date.now();
+      callback.apply(self2, args);
+    }
+    chunkC66X5FP6_cjs.__name(exec, "exec");
+    trailingExec = exec;
+    if (elapsed > delay || !timeoutID) {
+      if (leading) {
+        if (elapsed > delay) {
+          exec();
+        } else {
+          ++visited;
+        }
+      }
+      const timeout2 = elapsed > delay ? delay : delay - elapsed;
+      log6(`\u23F1 start timeout with ${timeout2.toFixed(1)}ms`, debugElapsed());
+      clearExistingTimeout();
+      checkpoint = now;
+      timeoutID = setTimeout(() => {
+        timeoutID = 0;
+        if (trailing && (!leading || visited > 0)) {
+          trailingExec == null ? void 0 : trailingExec();
+        }
+      }, timeout2);
+    } else {
+      ++visited;
+    }
+  }
+  chunkC66X5FP6_cjs.__name(wrapper, "wrapper");
+  wrapper.cancel = clearExistingTimeout;
+  wrapper.dispose = clearExistingTimeout;
+  return wrapper;
+}
+chunkC66X5FP6_cjs.__name(throttle, "throttle");
+function debounce(callback, opt = {}) {
+  const { delay = 100 } = opt;
+  let timeoutID = 0;
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+      timeoutID = 0;
+    }
+  }
+  chunkC66X5FP6_cjs.__name(clearExistingTimeout, "clearExistingTimeout");
+  function wrapper(...arguments_) {
+    let self2 = this;
+    clearExistingTimeout();
+    timeoutID = setTimeout(() => {
+      timeoutID = 0;
+      callback.apply(self2, arguments_);
+    }, delay);
+  }
+  chunkC66X5FP6_cjs.__name(wrapper, "wrapper");
+  wrapper.cancel = clearExistingTimeout;
+  wrapper.dispose = clearExistingTimeout;
+  return wrapper;
+}
+chunkC66X5FP6_cjs.__name(debounce, "debounce");
+
+// src/common/localhost.ts
+function isLocalHost(hostname = _nullishCoalesce(((_a) => (_a = globalThis == null ? void 0 : globalThis.location) == null ? void 0 : _a.hostname)(), () => ( ""))) {
+  return ["::ffff:127.0.0.1", "localhost", "127.0.0.1", "", "::1", "::"].includes(
+    hostname
+  ) || hostname.startsWith("192.168.") || hostname.startsWith("10.0.") || hostname.endsWith(".local");
+}
+chunkC66X5FP6_cjs.__name(isLocalHost, "isLocalHost");
+
+// src/common/log-memory.ts
+function LoggerMemoryHandler(opt) {
+  let { level = void 0, filter = void 0, messages: messages2 = [] } = opt;
+  const matchesNamespace = chunkC66X5FP6_cjs.useNamespaceFilter(filter);
+  const matchesLevel = chunkC66X5FP6_cjs.useLevelFilter(level);
+  return (msg) => {
+    if (!matchesLevel(msg.level))
+      return;
+    if (!matchesNamespace(msg.name))
+      return;
+    messages2.push(msg);
+  };
+}
+chunkC66X5FP6_cjs.__name(LoggerMemoryHandler, "LoggerMemoryHandler");
+
+// src/common/msg/channel.ts
+var Channel = class extends Emitter {
+  constructor() {
+    super(...arguments);
+    this.id = uuid();
+  }
+  close() {
+    this.dispose();
+  }
+};
+chunkC66X5FP6_cjs.__name(Channel, "Channel");
+var LocalChannel = class extends Channel {
+  constructor() {
+    super(...arguments);
+    this.isConnected = true;
+  }
+  postMessage(data) {
+    var _a;
+    (_a = this.other) == null ? void 0 : _a.emit("message", {
+      data,
+      origin: "local",
+      lastEventId: uuid()
+    });
+  }
+};
+chunkC66X5FP6_cjs.__name(LocalChannel, "LocalChannel");
+function createLocalChannelPair() {
+  let w1 = new LocalChannel();
+  let w2 = new LocalChannel();
+  w1.other = w2;
+  w2.other = w1;
+  return [w1, w2];
+}
+chunkC66X5FP6_cjs.__name(createLocalChannelPair, "createLocalChannelPair");
+
+// src/common/msg/encoder.ts
+var NoopEncoder = class {
+  async encode(data) {
+    return data;
+  }
+  async decode(data) {
+    return data;
+  }
+};
+chunkC66X5FP6_cjs.__name(NoopEncoder, "NoopEncoder");
+var JsonEncoder = class {
+  async encode(data) {
+    return jsonToUint8Array(data);
+  }
+  async decode(data) {
+    return Uint8ArrayToJson(data);
+  }
+};
+chunkC66X5FP6_cjs.__name(JsonEncoder, "JsonEncoder");
+var CryptoEncoder = class {
+  constructor(key) {
+    this.key = key;
+  }
+  async encode(data) {
+    const plain = jsonToUint8Array(data);
+    return await encrypt(plain, this.key);
+  }
+  async decode(data) {
+    const plain = await decrypt(data, this.key);
+    return Uint8ArrayToJson(plain);
+  }
+};
+chunkC66X5FP6_cjs.__name(CryptoEncoder, "CryptoEncoder");
+
+// src/common/msg/messages.ts
+var createPromiseProxy = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((fn, opt, predefinedMethods = {}) => new Proxy(predefinedMethods, {
+  get: (target, name) => {
+    if (name in target)
+      return target[name];
+    return (...args) => fn(name, args, opt);
+  }
+}), "createPromiseProxy");
+function useMessageHub(opt = {}) {
+  let {
+    name = uname("hub"),
+    encoder = new JsonEncoder(),
+    retryAfter = 1e3,
+    ignoreUnhandled = true,
+    logLevel = false
+  } = opt;
+  const log9 = chunkC66X5FP6_cjs.Logger(name, logLevel);
+  let handlers = {};
+  let channel;
+  let queue = [];
+  let queueRetryTimer;
+  let waitingForResponse = {};
+  const dispose = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(() => {
+    clearTimeout(queueRetryTimer);
+  }, "dispose");
+  const postNext = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async () => {
+    clearTimeout(queueRetryTimer);
+    if (channel) {
+      if (channel.isConnected) {
+        while (queue.length) {
+          let message = queue[0];
+          try {
+            channel.postMessage(await encoder.encode(message));
+            queue.shift();
+          } catch (err) {
+            log9.warn("postMessage", err);
+            break;
+          }
+        }
+      }
+      if (queue.length > 0 && retryAfter > 0) {
+        queueRetryTimer = setTimeout(postNext, retryAfter);
+      }
+    }
+  }, "postNext");
+  const postMessage = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async (message) => {
+    log9("enqueue postMessage", message);
+    queue.push(message);
+    await postNext();
+  }, "postMessage");
+  const connect = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async (newChannel) => {
+    channel = newChannel;
+    channel.on("connect", postNext);
+    channel.on("message", async (msg) => {
+      log9("onmessage", typeof msg);
+      const { name: name2, args, id, result, error } = await encoder.decode(msg.data);
+      if (name2) {
+        log9(`name ${name2} id ${id}`);
+        try {
+          if (handlers[name2] == null) {
+            throw new Error(`handler for ${name2} was not found`);
+          }
+          let result2 = handlers[name2](...args);
+          if (isPromise(result2))
+            result2 = await result2;
+          log9(`result ${result2}`);
+          if (id) {
+            postMessage({ id, result: result2 });
+          }
+        } catch (error2) {
+          let err = error2 instanceof Error ? error2 : new Error(valueToString(error2));
+          log9.warn("execution error", err.name);
+          postMessage({
+            id,
+            error: {
+              message: err.message,
+              stack: err.stack,
+              name: err.name
+            }
+          });
+        }
+      } else if (id) {
+        log9(`response for id=${id}: result=${result}, error=${error}`);
+        if (waitingForResponse[id] == null) {
+          if (result === void 0) {
+            log9(`skip response for ${id}`);
+          } else {
+            log9.warn(`no response hook for ${id}`);
+          }
+        } else {
+          const [resolve, reject] = waitingForResponse[id];
+          if (resolve && reject) {
+            delete waitingForResponse[id];
+            if (error) {
+              let err = new Error(error.message);
+              err.stack = error.stack;
+              err.name = error.name;
+              log9.warn("reject", err.name);
+              reject(err);
+            } else {
+              log9("resolve", result);
+              resolve(result);
+            }
+          }
+        }
+      } else if (!ignoreUnhandled) {
+        log9.warn("Unhandled message", msg);
+      }
+    });
+    postNext();
+  }, "connect");
+  const fetchMessage = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(async (name2, args, opt2 = {}) => {
+    const { timeout: timeout2 = 5e3 } = opt2;
+    const id = uuid();
+    postMessage({
+      name: name2,
+      args,
+      id
+    });
+    return tryTimeout(
+      new Promise(
+        (resolve, reject) => waitingForResponse[id] = [resolve, reject]
+      ),
+      timeout2
+    );
+  }, "fetchMessage");
+  if (opt.channel) {
+    connect(opt.channel);
+  }
+  return {
+    dispose,
+    connect,
+    listen(newHandlers) {
+      Object.assign(handlers, newHandlers);
+    },
+    send() {
+      return createPromiseProxy(fetchMessage, {}, {
+        options(perCallopt) {
+          return createPromiseProxy(fetchMessage, { ...perCallopt });
+        }
+      });
+    }
+  };
+}
+chunkC66X5FP6_cjs.__name(useMessageHub, "useMessageHub");
+
+// src/common/msg/pubsub.ts
+var PubSub = class extends Emitter {
+  constructor(opt) {
+    super();
+    this.publish = this.emit;
+    this.subscribe = this.on;
+    let { name, encoder = new JsonEncoder(), channel, debug = false } = opt;
+    this.channel = channel;
+    this.encoder = encoder;
+    this.debug = debug;
+    this.name = _nullishCoalesce(_nullishCoalesce(name, () => ( this.channel.id)), () => ( uname("pubsub")));
+    this.log = chunkC66X5FP6_cjs.Logger(`${this.shortId}`);
+    if (this.debug) {
+      this.channel.on("connect", () => {
+        this.log("channel connected");
+      });
+      this.channel.on("disconnect", () => {
+        this.log("channel disconnected");
+      });
+    }
+    this.channel.on("message", async ({ data }) => {
+      let info = await this.encoder.decode(data);
+      if (this.debug)
+        this.log(`channel message, event=${info == null ? void 0 : info.event}, info=`, info);
+      else
+        this.log(`channel message, event=${info == null ? void 0 : info.event}`);
+      if (info) {
+        const { event, args } = info;
+        await this.emitSuper(event, ...args);
+      }
+    });
+  }
+  get shortId() {
+    return this.name.substr(0, 6);
+  }
+  async emitSuper(event, ...args) {
+    return await super.emit(event, ...args);
+  }
+  async emit(event, ...args) {
+    try {
+      if (this.debug)
+        this.log(`emit(${String(event)})`, event);
+      else
+        this.log(`emit(${String(event)})`, args.length);
+      if (!this.channel.isConnected) {
+        this.log.warn("channel not connected");
+        return false;
+      }
+      const data = await this.encoder.encode({ event, args });
+      this.channel.postMessage(data);
+      return true;
+    } catch (err) {
+      this.log.warn(`emit(${String(event)})`, err);
+    }
+    return false;
+  }
+};
+chunkC66X5FP6_cjs.__name(PubSub, "PubSub");
+function usePubSub(opt) {
+  return new PubSub(opt);
+}
+chunkC66X5FP6_cjs.__name(usePubSub, "usePubSub");
+
+// src/common/msg/rpc.ts
+var rpcCounter = 1;
+var defaultSerialize = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((i) => i, "defaultSerialize");
+var defaultDeserialize = defaultSerialize;
+function useRPC(functions, options) {
+  const {
+    post,
+    on,
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  on(async (data) => {
+    const msg = deserialize(data);
+    const [mode, args, id, method] = msg;
+    if (mode === 1 /* request */ || mode === 2 /* event */) {
+      let result, error;
+      if (method != null) {
+        try {
+          result = await functions[method](...args);
+        } catch (e) {
+          error = String(e);
+        }
+      } else {
+        error = "Method implementation missing";
+      }
+      if (mode === 1 /* request */ && id) {
+        if (error) {
+          post(serialize([4 /* reject */, error, id]));
+        } else {
+          post(serialize([3 /* resolve */, result, id]));
+        }
+      }
+    } else if (id) {
+      const promise = rpcPromiseMap.get(id);
+      if (promise != null) {
+        if (mode === 4 /* reject */)
+          promise.reject(args);
+        else
+          promise.resolve(args);
+      }
+      rpcPromiseMap.delete(id);
+    }
+  });
+  return new Proxy(
+    {},
+    {
+      get(_, method) {
+        const sendEvent = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((...args) => {
+          post(serialize([2 /* event */, args, null, method]));
+        }, "sendEvent");
+        if (options.onlyEvents || eventNames.includes(method)) {
+          sendEvent.asEvent = sendEvent;
+          return sendEvent;
+        }
+        const sendCall = /* @__PURE__ */ chunkC66X5FP6_cjs.__name((...args) => {
+          return new Promise((resolve, reject) => {
+            const id = rpcCounter++;
+            rpcPromiseMap.set(id, { resolve, reject });
+            post(serialize([1 /* request */, args, id, method]));
+          });
+        }, "sendCall");
+        sendCall.asEvent = sendEvent;
+        return sendCall;
+      }
+    }
+  );
+}
+chunkC66X5FP6_cjs.__name(useRPC, "useRPC");
+
+// src/common/network.ts
+var log7 = chunkC66X5FP6_cjs.Logger("network");
+var defaultOptions = {
+  cache: "no-cache",
+  redirect: "follow",
+  headers: {}
+};
+function parseBasicAuth(url) {
+  let m = /:\/\/([^@]*)@/gi.exec(url);
+  if (m && m[1]) {
+    let [username, password] = m[1].split(":", 2);
+    return {
+      url: url.replace(m[1] + "@", ""),
+      username,
+      password
+    };
+  }
+}
+chunkC66X5FP6_cjs.__name(parseBasicAuth, "parseBasicAuth");
+async function fetchBasic(url, fetchOptions = {}, fetchFn = fetch) {
+  try {
+    if (chunkC66X5FP6_cjs.isArray(fetchOptions)) {
+      fetchOptions = chunkC66X5FP6_cjs.deepMerge({}, ...arrayFlatten(fetchOptions));
+    }
+    let auth = parseBasicAuth(String(url));
+    if (auth) {
+      url = auth.url;
+      fetchOptions = chunkC66X5FP6_cjs.deepMerge(
+        {},
+        fetchOptions,
+        fetchOptionsBasicAuth(auth.username, auth.password)
+      );
+    }
+    if (fetchOptions.headers != null && !(fetchOptions.headers instanceof Headers)) {
+      fetchOptions.headers = new Headers(fetchOptions.headers);
+    }
+    log7("fetch", url, fetchOptions);
+    const response = await fetchFn(String(url), fetchOptions);
+    if (response.status < 400) {
+      return response;
+    }
+    try {
+      log7.warn(
+        `Fetch of ${url} with ${fetchOptions} returned status=${response.status}`
+      );
+      log7.warn(`Response: ${await response.text()}`);
+    } catch (err) {
+      log7.error("Exception:", err);
+    }
+  } catch (err) {
+    log7.error("fetchBasic", err);
+  }
+}
+chunkC66X5FP6_cjs.__name(fetchBasic, "fetchBasic");
+async function fetchJson(url, fetchOptions = {}, fetchFn = fetch) {
+  try {
+    let res = await fetchBasic(
+      url,
+      [
+        {
+          method: "GET",
+          headers: {
+            Accept: "application/json"
+          }
+        },
+        fetchOptions
+      ],
+      fetchFn
+    );
+    if (res) {
+      return await res.json();
+    }
+  } catch (err) {
+    log7.error("fetchJSON error:", err);
+  }
+}
+chunkC66X5FP6_cjs.__name(fetchJson, "fetchJson");
+async function fetchText(url, fetchOptions = {}, fetchFn = fetch) {
+  try {
+    let res = await fetchBasic(
+      url,
+      [defaultOptions, { method: "GET" }, fetchOptions],
+      fetchFn
+    );
+    if (res) {
+      return await res.text();
+    }
+  } catch (err) {
+    log7.error("fetchHTML error:", err);
+  }
+}
+chunkC66X5FP6_cjs.__name(fetchText, "fetchText");
+function fetchOptionsFormURLEncoded(data, method = "POST") {
+  return {
+    method,
+    ...defaultOptions,
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
+    },
+    body: encodeQuery(data)
+  };
+}
+chunkC66X5FP6_cjs.__name(fetchOptionsFormURLEncoded, "fetchOptionsFormURLEncoded");
+function fetchOptionsJson(data, method = "POST") {
+  return {
+    method,
+    ...defaultOptions,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8"
+    },
+    body: JSON.stringify(data)
+  };
+}
+chunkC66X5FP6_cjs.__name(fetchOptionsJson, "fetchOptionsJson");
+function fetchOptionsBasicAuth(username, password) {
+  return {
+    headers: {
+      Authorization: "Basic " + toBase64(username + ":" + password)
+    }
+  };
+}
+chunkC66X5FP6_cjs.__name(fetchOptionsBasicAuth, "fetchOptionsBasicAuth");
+
+// src/common/platform.ts
+function getWindow() {
+  if (typeof window !== "undefined")
+    return window;
+}
+chunkC66X5FP6_cjs.__name(getWindow, "getWindow");
+function getNavigator() {
+  if (typeof navigator !== "undefined")
+    return navigator;
+}
+chunkC66X5FP6_cjs.__name(getNavigator, "getNavigator");
+function getGlobal() {
+  return _nullishCoalesce(getWindow(), () => ( typeof WorkerGlobalScope !== "undefined")) ? self : typeof global !== "undefined" ? global : Function("return this;")();
+}
+chunkC66X5FP6_cjs.__name(getGlobal, "getGlobal");
+var _navigator = getNavigator();
+var _window = getWindow();
+function detect(info = {
+  ios: false,
+  macos: false,
+  windows: false,
+  beaker: false,
+  electron: false,
+  wkwebview: false,
+  pwa: false,
+  pwaInstalled: false,
+  browser: false,
+  node: false,
+  worker: false,
+  test: false,
+  jest: false,
+  macosNative: false,
+  iosNative: false,
+  appleNative: false,
+  touch: false
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  info.ios = ((_a = _navigator == null ? void 0 : _navigator.platform) == null ? void 0 : _a.match(/(iPhone|iPod|iPad)/i)) != null;
+  info.macos = !!((_b = _navigator == null ? void 0 : _navigator.platform) == null ? void 0 : _b.startsWith("Mac"));
+  info.windows = !!((_c = _navigator == null ? void 0 : _navigator.platform) == null ? void 0 : _c.startsWith("Win"));
+  info.beaker = (_window == null ? void 0 : _window["beaker"]) != null;
+  info.electron = (((_e = (_d = _navigator == null ? void 0 : _navigator.userAgent) == null ? void 0 : _d.toLowerCase()) == null ? void 0 : _e.indexOf(" electron/")) || -1) > -1 && !info.beaker;
+  info.wkwebview = ((_f = _window == null ? void 0 : _window.webkit) == null ? void 0 : _f["messageHandlers"]) != null;
+  info.pwa = (_navigator == null ? void 0 : _navigator.serviceWorker) != null;
+  info.pwaInstalled = (_navigator == null ? void 0 : _navigator.standalone) || ((_h = (_g = _window == null ? void 0 : _window.matchMedia) == null ? void 0 : _g.call(_window, "(display-mode: standalone)")) == null ? void 0 : _h.matches);
+  info.node = typeof process !== "undefined" && ((_i = process == null ? void 0 : process.release) == null ? void 0 : _i.name) === "node";
+  info.browser = !info.electron && !info.wkwebview && !info.node;
+  info.worker = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+  info.jest = typeof jest !== "undefined" || typeof vitest !== "undefined";
+  info.test = info.jest;
+  info.macosNative = info.wkwebview && info.macos;
+  info.iosNative = info.wkwebview && info.ios;
+  info.appleNative = info.wkwebview;
+  info.touch = _window && "ontouchstart" in _window || ((_navigator == null ? void 0 : _navigator.maxTouchPoints) || 0) > 1 || (_navigator == null ? void 0 : _navigator.msPointerEnabled) && (_window == null ? void 0 : _window.MSGesture) || (_window == null ? void 0 : _window.DocumentTouch) && document instanceof DocumentTouch;
+  return info;
+}
+chunkC66X5FP6_cjs.__name(detect, "detect");
+var isBrowser = /* @__PURE__ */ chunkC66X5FP6_cjs.__name(() => typeof window !== "undefined" && globalThis === window, "isBrowser");
+var platform = detect();
+function useExitHandler(handler) {
+  if (isBrowser()) {
+    window.addEventListener("beforeunload", handler);
+  } else if (typeof process !== "undefined") {
+    process.on("exit", () => handler);
+  }
+}
+chunkC66X5FP6_cjs.__name(useExitHandler, "useExitHandler");
+
+// src/common/storage/memstorage.ts
+chunkC66X5FP6_cjs.Logger("zeed:memstorage");
+var MemStorage = class {
+  constructor(opt = {}) {
+    this.store = {};
+  }
+  setItem(key, value) {
+    this.store[key] = cloneObject(value);
+  }
+  getItem(key) {
+    if (this.store.hasOwnProperty(key)) {
+      return cloneObject(this.store[key]);
+    }
+  }
+  removeItem(key) {
+    delete this.store[key];
+  }
+  clear() {
+    this.store = {};
+  }
+  allKeys() {
+    return Object.keys(this.store);
+  }
+};
+chunkC66X5FP6_cjs.__name(MemStorage, "MemStorage");
+
+exports.Channel = Channel;
+exports.CryptoEncoder = CryptoEncoder;
+exports.Currency = Currency;
+exports.DAY_MS = DAY_MS;
+exports.Day = Day;
+exports.Emitter = Emitter;
+exports.JsonEncoder = JsonEncoder;
+exports.LocalChannel = LocalChannel;
+exports.LoggerMemoryHandler = LoggerMemoryHandler;
+exports.MemStorage = MemStorage;
+exports.NoopEncoder = NoopEncoder;
+exports.PoolTaskIdConflictResolution = PoolTaskIdConflictResolution;
+exports.PoolTaskState = PoolTaskState;
+exports.PubSub = PubSub;
+exports.SerialQueue = SerialQueue;
+exports.Uint8ArrayToHexDump = Uint8ArrayToHexDump;
+exports.Uint8ArrayToJson = Uint8ArrayToJson;
+exports.Uint8ArrayToString = Uint8ArrayToString;
+exports.XRX = XRX;
+exports._decodeUtf8Polyfill = _decodeUtf8Polyfill;
+exports._encodeUtf8Polyfill = _encodeUtf8Polyfill;
+exports.arrayAvg = arrayAvg;
+exports.arrayBatches = arrayBatches;
+exports.arrayEmptyInPlace = arrayEmptyInPlace;
+exports.arrayFilterInPlace = arrayFilterInPlace;
+exports.arrayFlatten = arrayFlatten;
+exports.arrayIntersection = arrayIntersection;
+exports.arrayIsEqual = arrayIsEqual;
+exports.arrayMax = arrayMax;
+exports.arrayMin = arrayMin;
+exports.arrayMinus = arrayMinus;
+exports.arrayRandomElement = arrayRandomElement;
+exports.arrayRemoveElement = arrayRemoveElement;
+exports.arraySetElement = arraySetElement;
+exports.arrayShuffle = arrayShuffle;
+exports.arrayShuffleForce = arrayShuffleForce;
+exports.arrayShuffleInPlace = arrayShuffleInPlace;
+exports.arraySorted = arraySorted;
+exports.arraySortedNumbers = arraySortedNumbers;
+exports.arraySum = arraySum;
+exports.arraySymmetricDifference = arraySymmetricDifference;
+exports.arrayToggleInPlace = arrayToggleInPlace;
+exports.arrayUnion = arrayUnion;
+exports.arrayUnique = arrayUnique;
+exports.avg = avg;
+exports.between = between;
+exports.cloneJsonObject = cloneJsonObject;
+exports.cloneObject = cloneObject;
+exports.cmp = cmp;
+exports.composeOrderby = composeOrderby;
+exports.createArray = createArray;
+exports.createLocalChannelPair = createLocalChannelPair;
+exports.createPromise = createPromise;
+exports.createPromiseProxy = createPromiseProxy;
+exports.csv = csv;
+exports.currency = currency;
+exports.dateStringToDays = dateStringToDays;
+exports.day = day;
+exports.dayDay = dayDay;
+exports.dayDiff = dayDiff;
+exports.dayFromAny = dayFromAny;
+exports.dayFromDate = dayFromDate;
+exports.dayFromDateGMT = dayFromDateGMT;
+exports.dayFromParts = dayFromParts;
+exports.dayFromString = dayFromString;
+exports.dayFromTimestamp = dayFromTimestamp;
+exports.dayFromToday = dayFromToday;
+exports.dayMonth = dayMonth;
+exports.dayMonthStart = dayMonthStart;
+exports.dayOffset = dayOffset;
+exports.dayToDate = dayToDate;
+exports.dayToDateGMT = dayToDateGMT;
+exports.dayToParts = dayToParts;
+exports.dayToString = dayToString;
+exports.dayToTimestamp = dayToTimestamp;
+exports.dayYear = dayYear;
+exports.dayYearStart = dayYearStart;
+exports.debounce = debounce;
+exports.decimal = decimal;
+exports.decimalCentsPart = decimalCentsPart;
+exports.decimalFromCents = decimalFromCents;
+exports.decimalToCents = decimalToCents;
+exports.decodeBase16 = decodeBase16;
+exports.decodeBase32 = decodeBase32;
+exports.decodeBase58 = decodeBase58;
+exports.decodeBase62 = decodeBase62;
+exports.decodeBase64 = decodeBase64;
+exports.decrypt = decrypt;
+exports.deriveKeyPbkdf2 = deriveKeyPbkdf2;
+exports.detect = detect;
+exports.digest = digest;
+exports.empty = empty;
+exports.encodeBase16 = encodeBase16;
+exports.encodeBase32 = encodeBase32;
+exports.encodeBase58 = encodeBase58;
+exports.encodeBase62 = encodeBase62;
+exports.encodeBase64 = encodeBase64;
+exports.encodeQuery = encodeQuery;
+exports.encrypt = encrypt;
+exports.endSortWeight = endSortWeight;
+exports.ensureKey = ensureKey;
+exports.ensureKeyAsync = ensureKeyAsync;
+exports.equalBinary = equalBinary;
+exports.escapeHTML = escapeHTML;
+exports.escapeRegExp = escapeRegExp;
+exports.fetchBasic = fetchBasic;
+exports.fetchJson = fetchJson;
+exports.fetchOptionsBasicAuth = fetchOptionsBasicAuth;
+exports.fetchOptionsFormURLEncoded = fetchOptionsFormURLEncoded;
+exports.fetchOptionsJson = fetchOptionsJson;
+exports.fetchText = fetchText;
+exports.fixBrokenUth8String = fixBrokenUth8String;
+exports.forEachDay = forEachDay;
+exports.forTimes = forTimes;
+exports.formatMessages = formatMessages;
+exports.fromBase64 = fromBase64;
+exports.fromCamelCase = fromCamelCase;
+exports.getGlobal = getGlobal;
+exports.getGlobalEmitter = getGlobalEmitter;
+exports.getNavigator = getNavigator;
+exports.getSecureRandom = getSecureRandom;
+exports.getSecureRandomIfPossible = getSecureRandomIfPossible;
+exports.getWindow = getWindow;
+exports.immediate = immediate;
+exports.isBrowser = isBrowser;
+exports.isEven = isEven;
+exports.isHalf = isHalf;
+exports.isLocalHost = isLocalHost;
+exports.isPrime = isPrime;
+exports.isPrimeRX = isPrimeRX;
+exports.isPromise = isPromise;
+exports.isTimeout = isTimeout;
+exports.joinToUint8Array = joinToUint8Array;
+exports.jsonStringify = jsonStringify;
+exports.jsonToUint8Array = jsonToUint8Array;
+exports.last = last;
+exports.lazyListener = lazyListener;
+exports.linkifyPlainText = linkifyPlainText;
+exports.memoize = memoize;
+exports.messages = messages;
+exports.moveSortWeight = moveSortWeight;
+exports.parseBasicAuth = parseBasicAuth;
+exports.parseOrderby = parseOrderby;
+exports.parseQuery = parseQuery;
+exports.platform = platform;
+exports.promisify = promisify;
+exports.qid = qid;
+exports.randomBoolean = randomBoolean;
+exports.randomFloat = randomFloat;
+exports.randomInt = randomInt;
+exports.randomUint8Array = randomUint8Array;
+exports.regExpEscape = regExpEscape;
+exports.regExpString = regExpString;
+exports.renderMessages = renderMessages;
+exports.roundDown = roundDown;
+exports.roundHalfAwayFromZero = roundHalfAwayFromZero;
+exports.roundHalfDown = roundHalfDown;
+exports.roundHalfEven = roundHalfEven;
+exports.roundHalfOdd = roundHalfOdd;
+exports.roundHalfTowardsZero = roundHalfTowardsZero;
+exports.roundHalfUp = roundHalfUp;
+exports.roundUp = roundUp;
+exports.size = size;
+exports.sleep = sleep;
+exports.sortedItems = sortedItems;
+exports.sortedOrderby = sortedOrderby;
+exports.startSortWeight = startSortWeight;
+exports.stringToBoolean = stringToBoolean;
+exports.stringToFloat = stringToFloat;
+exports.stringToInteger = stringToInteger;
+exports.stringToUInt8Array = stringToUInt8Array;
+exports.suid = suid;
+exports.suidBytes = suidBytes;
+exports.suidBytesDate = suidBytesDate;
+exports.suidDate = suidDate;
+exports.sum = sum;
+exports.throttle = throttle;
+exports.timeout = timeout;
+exports.timeoutReached = timeoutReached;
+exports.timoutError = timoutError;
+exports.toBase64 = toBase64;
+exports.toBase64Url = toBase64Url;
+exports.toBool = toBool;
+exports.toCamelCase = toCamelCase;
+exports.toCapitalize = toCapitalize;
+exports.toCapitalizeWords = toCapitalizeWords;
+exports.toFloat = toFloat;
+exports.toHex = toHex;
+exports.toHumanReadableUrl = toHumanReadableUrl;
+exports.toInt = toInt;
+exports.toString = toString;
+exports.toUint8Array = toUint8Array;
+exports.toValidFilename = toValidFilename;
+exports.today = today;
+exports.tryTimeout = tryTimeout;
+exports.uname = uname;
+exports.unescapeHTML = unescapeHTML;
+exports.useAsyncMutex = useAsyncMutex;
+exports.useBase = useBase;
+exports.useDefer = useDefer;
+exports.useDispose = useDispose;
+exports.useDisposer = useDisposer;
+exports.useEventListener = useEventListener;
+exports.useExitHandler = useExitHandler;
+exports.useInterval = useInterval;
+exports.useMessageHub = useMessageHub;
+exports.useMutex = useMutex;
+exports.usePool = usePool;
+exports.usePubSub = usePubSub;
+exports.useRPC = useRPC;
+exports.useTimeout = useTimeout;
+exports.uuid = uuid;
+exports.uuid32Decode = uuid32Decode;
+exports.uuid32Encode = uuid32Encode;
+exports.uuid32bit = uuid32bit;
+exports.uuidB32 = uuidB32;
+exports.uuidBytes = uuidBytes;
+exports.uuidDecode = uuidDecode;
+exports.uuidEncode = uuidEncode;
+exports.uuidv4 = uuidv4;
+exports.valueToBoolean = valueToBoolean;
+exports.valueToFloat = valueToFloat;
+exports.valueToInteger = valueToInteger;
+exports.valueToString = valueToString;
+exports.waitOn = waitOn;
+//# sourceMappingURL=chunk-AITOWUS2.cjs.map