gofront 1.5.1 → 1.6.1

package/src/backend/js/runtime.js

@@ -43,21 +43,98 @@ export const HELPER_SCLONE = `var __sclone = __sclone || function(x) {
 
 // Interface boxing: tag struct values (__v) vs struct pointers (__p) so type
 // switches can tell T from *T; tags are non-enumerable so __equal/JSON ignore them.
-export const HELPER_IFACE_BOX = `var __ifv = __ifv || function(x) {
+export const HELPER_IFACE_BOX = `var __ifv = __ifv || function(x, ptrFields) {
   if (x === null || typeof x !== "object") return x;
   const c = typeof x.__clone === "function" ? x.__clone() : Object.assign(Object.create(Object.getPrototypeOf(x)), x);
   Object.defineProperty(c, "__v", { value: true, configurable: true });
+  if (Array.isArray(ptrFields)) {
+    for (const f of ptrFields) {
+      if (f.indexOf(".") !== -1) {
+        const parts = f.split(".");
+        let cur = c;
+        for (let j = 0; j < parts.length - 1; j++) cur = cur?.[parts[j]];
+        const last = parts[parts.length - 1];
+        if (cur?.[last] !== null && typeof cur?.[last] === "object") __ifp(cur[last]);
+      } else if (c[f] !== null && typeof c[f] === "object") {
+        __ifp(c[f]);
+      }
+    }
+  }
+  for (const k of Object.keys(c)) {
+    if (c[k] !== null && typeof c[k] === "object" && !Array.isArray(c[k]) && !ArrayBuffer.isView(c[k])) {
+      if (!c[k].__v && !c[k].__p && (!Array.isArray(ptrFields) || !ptrFields.includes(k))) {
+        Object.defineProperty(c[k], "__v", { value: true, configurable: true });
+      }
+    }
+  }
   return c;
 };
-var __ifp = __ifp || function(x) {
-  if (x !== null && typeof x === "object" && x.__p !== true && Object.isExtensible(x))
+var __ifp = __ifp || function(x, ptrFields, seen) {
+  if (x === null || typeof x !== "object") return x;
+  if (x.__p !== true && Object.isExtensible(x))
     Object.defineProperty(x, "__p", { value: true, configurable: true });
+  if (Array.isArray(ptrFields)) {
+    seen = seen || new Set();
+    if (seen.has(x)) return x;
+    seen.add(x);
+    for (const f of ptrFields) {
+      if (f.indexOf(".") !== -1) {
+        const parts = f.split(".");
+        let cur = x;
+        for (let j = 0; j < parts.length - 1; j++) cur = cur?.[parts[j]];
+        const last = parts[parts.length - 1];
+        if (cur?.[last] !== null && typeof cur?.[last] === "object") __ifp(cur[last]);
+      } else if (x[f] !== null && typeof x[f] === "object") {
+        __ifp(x[f]);
+      }
+    }
+  }
+  return x;
+};
+var __ifm = __ifm || function(x) {
+  if (x === null || x === undefined) return x;
+  if (typeof x !== "object") return x;
+  if (x.__map !== true && Object.isExtensible(x))
+    Object.defineProperty(x, "__map", { value: true, configurable: true });
+  return x;
+};
+var __ifpm = __ifpm || function(x) {
+  if (x === null || x === undefined) return x;
+  if (typeof x !== "object") return x;
+  if (x.__map !== true && Object.isExtensible(x)) {
+    Object.defineProperty(x, "__map", { value: true, configurable: true });
+    Object.defineProperty(x, "__ptr_map", { value: true, configurable: true });
+  }
+  return x;
+};
+var __ifs = __ifs || function(x, ptrFields) {
+  if (x === null || x === undefined) return x;
+  if (x.__slice !== true && Object.isExtensible(x))
+    Object.defineProperty(x, "__slice", { value: true, configurable: true });
+  if (Array.isArray(ptrFields) && Object.isExtensible(x))
+    Object.defineProperty(x, "__ptr_fields", { value: ptrFields, configurable: true });
+  return x;
+};
+var __ifps = __ifps || function(x) {
+  if (x === null || x === undefined) return x;
+  if (x.__slice !== true && Object.isExtensible(x)) {
+    Object.defineProperty(x, "__slice", { value: true, configurable: true });
+    Object.defineProperty(x, "__ptr_slice", { value: true, configurable: true });
+  }
+  return x;
+};`;
+
+// Nil-interface method call guard (strict mode only): matches Go's panic
+// message instead of a JS TypeError.
+export const HELPER_NIL_CALL = `var __nilcall = __nilcall || function(x) {
+  if (x == null) throw new Error("runtime error: invalid memory address or nil pointer dereference");
   return x;
 };`;
 
 export const HELPER_EQUAL = `var __equal = __equal || function __equal(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
   if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
     if (a.byteLength !== b.byteLength || a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
@@ -86,9 +163,149 @@ export const HELPER_CDIV = `var __cdiv = __cdiv || function(a, b) {
   return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d };
 };`;
 
+// Panic/defer runtime.  \`stack\` holds the in-flight panic of every frame
+// currently running its defers; \`armed\` is set right before a deferred
+// function is invoked and consumed by that function's prologue, so recover()
+// only takes effect when called directly by the deferred function (Go spec).
+export const HELPER_PANIC = `var __gopanic = __gopanic || { stack: [], armed: false };
+var __runDefers = __runDefers || function(defers, frame) {
+  for (let i = defers.length - 1; i >= 0; i--) {
+    __gopanic.armed = true;
+    try { defers[i](); }
+    catch (e) {
+      if (frame.pn !== null) __gopanic.stack.pop();
+      frame.pn = { err: e, recovered: false };
+      __gopanic.stack.push(frame.pn);
+    } finally { __gopanic.armed = false; }
+  }
+  if (frame.pn !== null) {
+    __gopanic.stack.pop();
+    if (!frame.pn.recovered) throw frame.pn.err;
+  }
+};
+var __recover = __recover || function(ok) {
+  if (!ok) return null;
+  const s = __gopanic.stack;
+  const top = s.length > 0 ? s[s.length - 1] : null;
+  if (top === null || top.recovered) return null;
+  top.recovered = true;
+  return top.err?.message ?? String(top.err);
+};`;
+
 export const HELPER_SPRINTF = `var __sprintf = __sprintf || function(f, ...a) {
   let i = 0;
-  return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGw%]/g, (m) => {
+  const ptrMap = new WeakMap();
+  const ptrSet = new WeakSet();
+  let ptrCounter = 1;
+  const getPtr = (o) => {
+    let p = ptrMap.get(o);
+    if (!p) {
+      p = "0x" + (ptrCounter++).toString(16);
+      ptrMap.set(o, p);
+    }
+    return p;
+  };
+  const markPtr = (o) => {
+    if (o !== null && typeof o === "object") ptrSet.add(o);
+  };
+  const isPointer = (o) => {
+    return o !== null && typeof o === "object" && (o.__p === true || ptrSet.has(o));
+  };
+  const formatV = (val, isPlus, isTopLevel) => {
+    if (val === null || val === undefined) return "<nil>";
+    if (typeof val === "boolean") return String(val);
+    if (typeof val === "number" || typeof val === "bigint") return String(val);
+    if (typeof val === "string") return val;
+    if (typeof val === "object") {
+      if (val._d instanceof Date) {
+        return typeof __timeFmt === "function" ? __timeFmt(val, "2006-01-02 15:04:05.999999999 -0700 MST") : String(val._d);
+      }
+      if ("re" in val && "im" in val) {
+        const sign = val.im >= 0 ? "+" : "";
+        return "(" + val.re + sign + val.im + "i)";
+      }
+      if (typeof val.Error === "function") {
+        return String(val.Error());
+      }
+      if (Array.isArray(val) || ArrayBuffer.isView(val)) {
+        const isElemPtr = val.__ptr_slice === true;
+        const pf = val.__ptr_fields;
+        const parts = [];
+        for (let j = 0; j < val.length; j++) {
+          const item = val[j];
+          if (isElemPtr && item !== null && typeof item === "object") {
+            markPtr(item);
+          } else if (Array.isArray(pf) && item !== null && typeof item === "object") {
+            for (const f of pf) {
+              if (f.indexOf(".") !== -1) {
+                const fparts = f.split(".");
+                let cur = item;
+                for (let k = 0; k < fparts.length - 1; k++) cur = cur?.[fparts[k]];
+                const last = fparts[fparts.length - 1];
+                if (cur?.[last] !== null && typeof cur?.[last] === "object") markPtr(cur[last]);
+              } else if (item[f] !== null && typeof item[f] === "object") {
+                markPtr(item[f]);
+              }
+            }
+          }
+          parts.push(formatV(item, isPlus, false));
+        }
+        return "[" + parts.join(" ") + "]";
+      }
+      if (val instanceof Map || val.__map === true) {
+        const isElemPtr = val.__ptr_map === true;
+        const parts = [];
+        if (val instanceof Map) {
+          const entries = Array.from(val.entries()).sort(([k1], [k2]) => {
+            if (typeof k1 === "number" && typeof k2 === "number") return k1 - k2;
+            const na = Number(k1), nb = Number(k2);
+            if (!Number.isNaN(na) && !Number.isNaN(nb)) return na - nb;
+            return String(k1).localeCompare(String(k2));
+          });
+          for (const [k, v] of entries) {
+            if (isElemPtr && v !== null && typeof v === "object") {
+              markPtr(v);
+            }
+            parts.push(formatV(k, isPlus, false) + ":" + formatV(v, isPlus, false));
+          }
+        } else {
+          const keys = Object.keys(val).sort((a, b) => {
+            const na = Number(a), nb = Number(b);
+            if (!Number.isNaN(na) && !Number.isNaN(nb)) return na - nb;
+            return a.localeCompare(b);
+          });
+          for (const k of keys) {
+            const v = val[k];
+            if (isElemPtr && v !== null && typeof v === "object") {
+              markPtr(v);
+            }
+            parts.push(formatV(k, isPlus, false) + ":" + formatV(v, isPlus, false));
+          }
+        }
+        return "map[" + parts.join(" ") + "]";
+      }
+      if ("value" in val && (val.__box === true || (!val.__struct && !("__v" in val) && Object.keys(val).length === 1 && (val.constructor === Object || !val.constructor || val.constructor?.name === "Object")))) {
+        return getPtr(val);
+      }
+      const isPtr = isPointer(val);
+      if (isPtr) {
+        if (!isTopLevel) {
+          return getPtr(val);
+        }
+        getPtr(val);
+      }
+      const prefix = isPtr ? "&{" : "{";
+      const keys = Object.keys(val);
+      const parts = [];
+      for (const k of keys) {
+        const fv = formatV(val[k], isPlus, false);
+        parts.push(isPlus ? k + ":" + fv : fv);
+      }
+      return prefix + parts.join(" ") + "}";
+    }
+    return String(val);
+  };
+  return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGwc%]/g, (m) => {
     if (m === "%%") return "%";
     const verb = m.slice(-1);
     const v = a[i++];
@@ -102,30 +319,46 @@ export const HELPER_SPRINTF = `var __sprintf = __sprintf || function(f, ...a) {
     };
     switch (verb) {
       case "s": return pad(String(v == null ? "<nil>" : v), width, false);
-      case "d": return pad(String(Math.trunc(Number(v))), width, zero);
+      case "c": return pad(String.fromCodePoint(Number(v)), width, false);
+      case "d": return pad(String(typeof v === "bigint" ? v : Math.trunc(Number(v))), width, zero);
       case "v": {
-        if (typeof v === "object" && v !== null) {
-          if ("re" in v && "im" in v) {
-            const sign = v.im >= 0 ? "+" : "";
-            return pad("(" + v.re + sign + v.im + "i)", width, false);
-          }
-          if (typeof v.Error === "function") {
-            return pad(String(v.Error()), width, false);
-          }
-          try {
-            return pad(JSON.stringify(v), width, false);
-          } catch {
-            return pad(String(v), width, false);
-          }
-        }
-        return pad(String(v == null ? "<nil>" : v), width, false);
+        const isPlus = flags?.includes("+") ?? false;
+        return pad(formatV(v, isPlus, true), width, false);
       }
       case "f": { const n = Number(v), p = prec !== "" ? parseInt(prec) : 6; return pad(n.toFixed(p), width, zero); }
       case "t": return pad(String(!!v), width, false);
-      case "x": return pad((Number(v) >>> 0).toString(16), width, zero);
-      case "X": return pad((Number(v) >>> 0).toString(16).toUpperCase(), width, zero);
-      case "o": return pad((Number(v) >>> 0).toString(8), width, zero);
-      case "b": return pad((Number(v) >>> 0).toString(2), width, zero);
+      case "x": {
+        let hex;
+        if (Array.isArray(v) || ArrayBuffer.isView(v)) {
+          hex = Array.from(v).map((b) => (Number(b) & 0xff).toString(16).padStart(2, "0")).join("");
+        } else if (typeof v === "string") {
+          hex = Array.from(new TextEncoder().encode(v)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        } else if (typeof v === "bigint") {
+          hex = BigInt.asUintN(64, v).toString(16);
+        } else if (Math.abs(Number(v)) > 0xffffffff) {
+          hex = (Math.trunc(Number(v) / 0x100000000) >>> 0).toString(16) + (Number(v) >>> 0).toString(16).padStart(8, "0");
+        } else {
+          hex = (Number(v) >>> 0).toString(16);
+        }
+        return pad(hex, width, zero);
+      }
+      case "X": {
+        let hex;
+        if (Array.isArray(v) || ArrayBuffer.isView(v)) {
+          hex = Array.from(v).map((b) => (Number(b) & 0xff).toString(16).padStart(2, "0").toUpperCase()).join("");
+        } else if (typeof v === "string") {
+          hex = Array.from(new TextEncoder().encode(v)).map((b) => b.toString(16).padStart(2, "0").toUpperCase()).join("");
+        } else if (typeof v === "bigint") {
+          hex = BigInt.asUintN(64, v).toString(16).toUpperCase();
+        } else if (Math.abs(Number(v)) > 0xffffffff) {
+          hex = (Math.trunc(Number(v) / 0x100000000) >>> 0).toString(16).toUpperCase() + (Number(v) >>> 0).toString(16).padStart(8, "0").toUpperCase();
+        } else {
+          hex = (Number(v) >>> 0).toString(16).toUpperCase();
+        }
+        return pad(hex, width, zero);
+      }
+      case "o": return pad((typeof v === "bigint" ? BigInt.asUintN(64, v).toString(8) : (Number(v) >>> 0).toString(8)), width, zero);
+      case "b": return pad((typeof v === "bigint" ? BigInt.asUintN(64, v).toString(2) : (Number(v) >>> 0).toString(2)), width, zero);
       case "q": return pad('"' + String(v == null ? "" : v).replace(/\\\\/g, "\\\\\\\\").replace(/"/g, '\\\\"') + '"', width, false);
       case "e": case "E": { const n = Number(v), p = prec !== "" ? parseInt(prec) : 6; return pad(n.toExponential(p), width, zero); }
       case "g": case "G": { const n = Number(v); return pad(prec !== "" ? n.toPrecision(parseInt(prec)) : String(n), width, zero); }
@@ -139,17 +372,184 @@ export const HELPER_ERROR = `var __error = __error || function(msg, cause) {
   return { Error() { return msg; }, toString() { return msg; }, _msg: msg, _cause: cause ?? null };
 };`;
 
-export const HELPER_ERROR_IS = `var __errorIs = __errorIs || function(err, target) {
-  while (err !== null && err !== undefined) {
-    if (err === target) return true;
-    if (typeof err === "object" && typeof target === "object" &&
-        err._msg !== undefined && target._msg !== undefined &&
-        err._msg === target._msg) return true;
-    err = err?._cause ?? null;
+export const HELPER_STRCONV_ERROR = `var __strconv_err_syntax = __strconv_err_syntax || __error("invalid syntax");
+var __strconv_err_range = __strconv_err_range || __error("value out of range");`;
+
+export const HELPER_PATH_ERROR = `var __path_err_bad_pattern = __path_err_bad_pattern || __error("syntax error in pattern");`;
+
+export const HELPER_IO_EOF = `var __io_eof = __io_eof || __error("EOF");`;
+
+export const HELPER_ERROR_IS = `var __errorIs = __errorIs || function __errorIs(err, target) {
+  if (err === null || err === undefined) return false;
+  if (err === target) return true;
+  if (typeof err === "object" && typeof target === "object" &&
+      err._msg !== undefined && target._msg !== undefined &&
+      err._msg === target._msg) return true;
+  if (typeof err.Is === "function" && err.Is(target)) return true;
+  if (Array.isArray(err._errs)) {
+    for (const sub of err._errs) {
+      if (__errorIs(sub, target)) return true;
+    }
+  }
+  if (typeof err.Unwrap === "function") {
+    const unwrapped = err.Unwrap();
+    if (Array.isArray(unwrapped)) {
+      for (const sub of unwrapped) {
+        if (__errorIs(sub, target)) return true;
+      }
+    } else if (unwrapped !== null && unwrapped !== undefined) {
+      if (__errorIs(unwrapped, target)) return true;
+    }
+  }
+  if (err._cause !== undefined && err._cause !== null) {
+    return __errorIs(err._cause, target);
   }
   return false;
 };`;
 
+export const HELPER_ERROR_AS = `var __errorAs = __errorAs || function(err, target, matcher) {
+  if (err === null || err === undefined || target === null || typeof target !== "object") return false;
+  let cur = err;
+  while (cur !== null && cur !== undefined) {
+    const unboxed = cur?.value ?? cur;
+    if (typeof cur.As === "function" && cur.As(target)) return true;
+    if (matcher ? matcher(unboxed) : (unboxed !== err && typeof unboxed === "object" && !("_msg" in unboxed && "_cause" in unboxed))) {
+      if ("value" in target) {
+        target.value = unboxed;
+      } else {
+        Object.assign(target, unboxed);
+      }
+      return true;
+    }
+    if (Array.isArray(cur._errs)) {
+      for (const sub of cur._errs) {
+        if (__errorAs(sub, target, matcher)) return true;
+      }
+    }
+    if (typeof cur.Unwrap === "function") {
+      const unwrapped = cur.Unwrap();
+      if (Array.isArray(unwrapped)) {
+        for (const sub of unwrapped) {
+          if (__errorAs(sub, target, matcher)) return true;
+        }
+      } else if (unwrapped !== null && unwrapped !== undefined) {
+        if (__errorAs(unwrapped, target, matcher)) return true;
+      }
+    }
+    cur = cur?._cause ?? null;
+  }
+  return false;
+};`;
+
+export const HELPER_ERROR_JOIN = `var __errorJoin = __errorJoin || function(...errs) {
+  const filtered = [];
+  for (const e of errs) {
+    if (Array.isArray(e)) {
+      for (const sub of e) if (sub !== null && sub !== undefined) filtered.push(sub);
+    } else if (e !== null && e !== undefined) {
+      filtered.push(e);
+    }
+  }
+  if (filtered.length === 0) return null;
+  const msg = filtered.map(e => (typeof e === "object" && typeof e.Error === "function") ? e.Error() : String(e)).join("\\n");
+  const joined = __error(msg);
+  joined._errs = filtered;
+  joined.Unwrap = function() { return filtered; };
+  return joined;
+};`;
+
+// Go-semantics strconv parsers shared by the JS backend and the wasm runtime
+// imports (boundary.js), so both targets agree.  Each parser returns
+// [value, errorMessage | null]; integer values are BigInt (the wasm side
+// needs i64, the JS side converts with Number()).
+export const HELPER_STRCONV = `var __strconv_atoi = __strconv_atoi || function(s) {
+  if (!/^[+-]?[0-9]+$/.test(s)) return [0n, 'strconv.Atoi: parsing "' + s + '": invalid syntax'];
+  const v = BigInt(s);
+  if (v > 9223372036854775807n || v < -9223372036854775808n) {
+    return [v > 0n ? 9223372036854775807n : -9223372036854775808n, 'strconv.Atoi: parsing "' + s + '": value out of range'];
+  }
+  return [v, null];
+};
+var __strconv_parse_int = __strconv_parse_int || function(s, base, bits) {
+  let str = s, neg = false;
+  if (str[0] === "-" || str[0] === "+") { neg = str[0] === "-"; str = str.slice(1); }
+  if (base === 0) {
+    if (/^0[xX]/.test(str)) { base = 16; str = str.slice(2); }
+    else if (/^0[bB]/.test(str)) { base = 2; str = str.slice(2); }
+    else if (/^0[oO]/.test(str)) { base = 8; str = str.slice(2); }
+    else if (/^0[0-9]/.test(str)) { base = 8; str = str.slice(1); }
+    else base = 10;
+    str = str.replaceAll("_", "");
+  }
+  if (base < 2 || base > 36) return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid base ' + base];
+  const digits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, base);
+  if (str === "" || [...str.toLowerCase()].some((c) => !digits.includes(c))) {
+    return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid syntax'];
+  }
+  let v = 0n; const B = BigInt(base);
+  for (const c of str.toLowerCase()) v = v * B + BigInt(digits.indexOf(c));
+  if (neg) v = -v;
+  const w = bits === 0 ? 64 : bits;
+  const max = (1n << BigInt(w - 1)) - 1n, min = -(1n << BigInt(w - 1));
+  if (v > max || v < min) return [v > max ? max : min, 'strconv.ParseInt: parsing "' + s + '": value out of range'];
+  return [v, null];
+};
+var __strconv_parse_uint = __strconv_parse_uint || function(s, base, bits) {
+  let str = s;
+  if (str[0] === "+") { str = str.slice(1); }
+  if (str[0] === "-") {
+    return [0n, 'strconv.ParseUint: parsing "' + s + '": invalid syntax'];
+  }
+  if (base === 0) {
+    if (/^0[xX]/.test(str)) { base = 16; str = str.slice(2); }
+    else if (/^0[bB]/.test(str)) { base = 2; str = str.slice(2); }
+    else if (/^0[oO]/.test(str)) { base = 8; str = str.slice(2); }
+    else if (/^0[0-9]/.test(str)) { base = 8; str = str.slice(1); }
+    else base = 10;
+    str = str.replaceAll("_", "");
+  }
+  if (base < 2 || base > 36) return [0n, 'strconv.ParseUint: parsing "' + s + '": invalid base ' + base];
+  const digits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, base);
+  if (str === "" || [...str.toLowerCase()].some((c) => !digits.includes(c))) {
+    return [0n, 'strconv.ParseUint: parsing "' + s + '": invalid syntax'];
+  }
+  let v = 0n; const B = BigInt(base);
+  for (const c of str.toLowerCase()) v = v * B + BigInt(digits.indexOf(c));
+  const w = bits === 0 ? 64 : bits;
+  const max = w >= 64 ? 18446744073709551615n : (1n << BigInt(w)) - 1n;
+  if (v > max) return [max, 'strconv.ParseUint: parsing "' + s + '": value out of range'];
+  return [v, null];
+};
+var __strconv_parse_float = __strconv_parse_float || function(s) {
+  const str = s.replaceAll("_", "");
+  if (/^[+-]?(inf|infinity)$/i.test(str)) return [str[0] === "-" ? -Infinity : Infinity, null];
+  if (/^[+-]?nan$/i.test(str)) return [NaN, null];
+  if (str === "" || !/^[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?$|^[+-]?0[xX][0-9a-fA-F]+$/.test(str)) {
+    return [0, 'strconv.ParseFloat: parsing "' + s + '": invalid syntax'];
+  }
+  return [Number(str), null];
+};
+var __strconv_parse_bool = __strconv_parse_bool || function(s) {
+  if (["1", "t", "T", "TRUE", "true", "True"].includes(s)) return [true, null];
+  if (["0", "f", "F", "FALSE", "false", "False"].includes(s)) return [false, null];
+  return [false, 'strconv.ParseBool: parsing "' + s + '": invalid syntax'];
+};
+var __strconv_format_float = __strconv_format_float || function(f, fmtc, prec) {
+  const c = String.fromCharCode(fmtc);
+  if (!Number.isFinite(f)) return f !== f ? "NaN" : (f > 0 ? "+Inf" : "-Inf");
+  if (c === "f") return prec < 0 ? String(f) : f.toFixed(prec);
+  if (c === "e" || c === "E") {
+    const r = prec < 0 ? f.toExponential() : f.toExponential(prec);
+    const o = r.replace(/e([+-])(\\d)$/, "e$10$2");
+    return c === "E" ? o.toUpperCase() : o;
+  }
+  if (c === "g" || c === "G") {
+    const r = prec < 0 ? String(f) : f.toPrecision(prec);
+    return c === "G" ? r.toUpperCase() : r;
+  }
+  return String(f);
+};`;
+
 export const HELPER_PATH_CLEAN = `var __pathClean = __pathClean || function(p) {
   if (!p) return ".";
   const abs = p.startsWith("/");
@@ -162,37 +562,159 @@ export const HELPER_PATH_CLEAN = `var __pathClean = __pathClean || function(p) {
     return acc;
   }, []);
   return (abs ? "/" : "") + (parts.join("/") || ".");
+};
+var __pathMatch = __pathMatch || function(pat, name) {
+  let rx = "^";
+  let hasErr = false;
+  let i = 0;
+  while (i < pat.length) {
+    const c = pat[i];
+    if (c === "\\\\") {
+      if (i + 1 >= pat.length) { hasErr = true; break; }
+      const next = pat[++i];
+      if (/[.^$*+?()|{}\\[\\]\\\\]/.test(next)) rx += "\\\\" + next;
+      else rx += next;
+      i++;
+    } else if (c === "*") {
+      rx += "[^/]*";
+      i++;
+    } else if (c === "?") {
+      rx += "[^/]";
+      i++;
+    } else if (c === "[") {
+      i++;
+      let negated = false;
+      if (i < pat.length && pat[i] === "^") {
+        negated = true;
+        i++;
+      }
+      if (i >= pat.length || pat[i] === "]") {
+        return [false, true];
+      }
+      let classContent = "";
+      let closed = false;
+      while (i < pat.length) {
+        let ch = pat[i];
+        if (ch === "]") {
+          closed = true;
+          i++;
+          break;
+        }
+        if (ch === "\\\\") {
+          if (i + 1 >= pat.length) { hasErr = true; break; }
+          ch = pat[++i];
+        }
+        if (ch === "/") {
+          return [false, true];
+        }
+        i++;
+        if (i + 1 < pat.length && pat[i] === "-" && pat[i + 1] !== "]") {
+          i++;
+          let end = pat[i];
+          if (end === "\\\\") {
+            if (i + 1 >= pat.length) { hasErr = true; break; }
+            end = pat[++i];
+          }
+          if (end === "/") return [false, true];
+          i++;
+          if (ch.charCodeAt(0) > end.charCodeAt(0)) return [false, true];
+          if (ch.charCodeAt(0) <= 47 && 47 <= end.charCodeAt(0)) return [false, true];
+          const isSpec = (c) => c === "-" || c === "^" || c === "\\\\" || c === "[" || c === "]";
+          const escCh = isSpec(ch) ? "\\\\" + ch : ch;
+          const escEnd = isSpec(end) ? "\\\\" + end : end;
+          classContent += escCh + "-" + escEnd;
+        } else {
+          const isSpec = (c) => c === "-" || c === "^" || c === "\\\\" || c === "[" || c === "]";
+          const escCh = isSpec(ch) ? "\\\\" + ch : ch;
+          classContent += escCh;
+        }
+      }
+      if (!closed || hasErr) return [false, true];
+      if (negated) {
+        rx += "[^/" + classContent + "]";
+      } else {
+        rx += "[" + classContent + "]";
+      }
+    } else if (/[.^$*+?()|{}\\[\\]\\\\]/.test(c)) {
+      rx += "\\\\" + c;
+      i++;
+    } else {
+      rx += c;
+      i++;
+    }
+  }
+  if (hasErr) return [false, true];
+  try {
+    const re = new RegExp(rx + "$");
+    return [re.test(name), false];
+  } catch (e) {
+    return [false, true];
+  }
 };`;
 
 export const HELPER_TIME_FMT = `var __timeFmt = __timeFmt || function(d, layout) {
+  const dt = d instanceof Date ? d : (d?._d ?? d);
+  const isUtc = d?._offset === 0;
   const pad = (n, w = 2) => String(n).padStart(w, "0");
   const DAYS = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
   const MONTHS = ["January","February","March","April","May","June","July","August","September","October","November","December"];
-  return layout.replace(/2006|06|Monday|Mon|January|Jan|01|1|02|2|15|PM|3|04|4|05|5|Z07:00|\\.000|\\.999/g, t => {
+  const getFullYear = () => isUtc ? dt.getUTCFullYear() : dt.getFullYear();
+  const getMonth = () => isUtc ? dt.getUTCMonth() : dt.getMonth();
+  const getDate = () => isUtc ? dt.getUTCDate() : dt.getDate();
+  const getDay = () => isUtc ? dt.getUTCDay() : dt.getDay();
+  const getHours = () => isUtc ? dt.getUTCHours() : dt.getHours();
+  const getMinutes = () => isUtc ? dt.getUTCMinutes() : dt.getMinutes();
+  const getSeconds = () => isUtc ? dt.getUTCSeconds() : dt.getSeconds();
+  const getMilliseconds = () => isUtc ? dt.getUTCMilliseconds() : dt.getMilliseconds();
+  const getTimezoneOffset = () => isUtc ? 0 : dt.getTimezoneOffset();
+  return layout.replace(/2006|06|Monday|Mon|January|Jan|01|02|15|PM|pm|03|04|05|Z07:00|-07:00|-0700|MST|\\.(?:0+|9+)|1|2|3|4|5/g, t => {
+    if (t.startsWith(".")) {
+      const isZeroPad = t.includes("0");
+      const maxLen = t.length - 1;
+      const ms = getMilliseconds();
+      let frac = pad(ms, 3);
+      if (maxLen > 3) frac = frac.padEnd(maxLen, "0");
+      else frac = frac.slice(0, maxLen);
+      if (!isZeroPad) {
+        frac = frac.replace(/0+$/, "");
+        return frac.length > 0 ? "." + frac : "";
+      } else {
+        return "." + frac;
+      }
+    }
     switch (t) {
-      case "2006": return d.getFullYear();
-      case "06":   return String(d.getFullYear()).slice(-2);
-      case "Monday": return DAYS[d.getDay()];
-      case "Mon":    return DAYS[d.getDay()].slice(0, 3);
-      case "January": return MONTHS[d.getMonth()];
-      case "Jan":     return MONTHS[d.getMonth()].slice(0, 3);
-      case "01": return pad(d.getMonth() + 1);
-      case "1":  return String(d.getMonth() + 1);
-      case "02": return pad(d.getDate());
-      case "2":  return String(d.getDate());
-      case "15": return pad(d.getHours());
-      case "PM": return d.getHours() < 12 ? "AM" : "PM";
-      case "3":  return String(d.getHours() % 12 || 12);
-      case "04": return pad(d.getMinutes());
-      case "4":  return String(d.getMinutes());
-      case "05": return pad(d.getSeconds());
-      case "5":  return String(d.getSeconds());
+      case "2006": return getFullYear();
+      case "06":   return String(getFullYear()).slice(-2);
+      case "Monday": return DAYS[getDay()];
+      case "Mon":    return DAYS[getDay()].slice(0, 3);
+      case "January": return MONTHS[getMonth()];
+      case "Jan":     return MONTHS[getMonth()].slice(0, 3);
+      case "01": return pad(getMonth() + 1);
+      case "1":  return String(getMonth() + 1);
+      case "02": return pad(getDate());
+      case "2":  return String(getDate());
+      case "15": return pad(getHours());
+      case "PM": return getHours() < 12 ? "AM" : "PM";
+      case "pm": return getHours() < 12 ? "am" : "pm";
+      case "03": return pad(getHours() % 12 || 12);
+      case "3":  return String(getHours() % 12 || 12);
+      case "04": return pad(getMinutes());
+      case "4":  return String(getMinutes());
+      case "05": return pad(getSeconds());
+      case "5":  return String(getSeconds());
       case "Z07:00": {
-        const o = -d.getTimezoneOffset();
+        const o = -getTimezoneOffset();
         return o === 0 ? "Z" : (o > 0 ? "+" : "-") + pad(Math.floor(Math.abs(o) / 60)) + ":" + pad(Math.abs(o) % 60);
       }
-      case ".000": return "." + pad(d.getMilliseconds(), 3);
-      case ".999": return d.getMilliseconds() > 0 ? "." + String(d.getMilliseconds()).replace(/0+$/, "") : "";
+      case "-07:00": {
+        const o = -getTimezoneOffset();
+        return (o >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(o) / 60)) + ":" + pad(Math.abs(o) % 60);
+      }
+      case "-0700": {
+        const o = -getTimezoneOffset();
+        return (o >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(o) / 60)) + pad(Math.abs(o) % 60);
+      }
+      case "MST": return isUtc ? "UTC" : "LOCAL";
       default: return t;
     }
   });
@@ -204,7 +726,7 @@ export const HELPER_TIME_PARSE = `var __timeParse = __timeParse || function(layo
     if (isNaN(d.getTime())) throw 0;
     return [{ _d: d }, null];
   } catch {
-    return [{ _d: new Date(0) }, "parsing time: cannot parse"];
+    return [{ _d: new Date(0) }, { Error() { return "parsing time: cannot parse"; }, toString() { return "parsing time: cannot parse"; }, _msg: "parsing time: cannot parse", _cause: null }];
   }
 };`;
 
@@ -323,3 +845,483 @@ export const HELPER_INJECT_STYLES = `var __injectStyles = __injectStyles || func
   }
   s.textContent += "\\n" + css;
 };`;
+
+export const HELPER_DURATION = `var __durationString = __durationString || function(d) {
+  d = BigInt(d);
+  if (d === 0n) return "0s";
+  let neg = false;
+  if (d < 0n) { neg = true; d = -d; }
+  let s = "";
+  const totalSec = d / 1000000000n;
+  const sec = totalSec % 60n;
+  const min = (totalSec / 60n) % 60n;
+  const hr = totalSec / 3600n;
+
+  if (hr > 0n) s += hr + "h";
+  const remAfterHr = d % 3600000000000n;
+  if (min > 0n || (hr > 0n && remAfterHr > 0n)) s += min + "m";
+  if (totalSec > 0n) {
+    const frac = d % 1000000000n;
+    if (sec > 0n || frac > 0n || (hr === 0n && min === 0n)) {
+      if (frac === 0n) {
+        s += sec + "s";
+      } else {
+        let fracStr = frac.toString().padStart(9, "0").replace(/0+$/, "");
+        s += sec + "." + fracStr + "s";
+      }
+    }
+  } else {
+    const ms = (d / 1000000n) % 1000n;
+    const us = (d / 1000n) % 1000n;
+    const ns = d % 1000n;
+    if (ms > 0n) {
+      const frac = d % 1000000n;
+      if (frac === 0n) s += ms + "ms";
+      else {
+        let fracStr = frac.toString().padStart(6, "0").replace(/0+$/, "");
+        s += ms + "." + fracStr + "ms";
+      }
+    } else if (us > 0n) {
+      const frac = d % 1000n;
+      if (frac === 0n) s += us + "µs";
+      else {
+        let fracStr = frac.toString().padStart(3, "0").replace(/0+$/, "");
+        s += us + "." + fracStr + "µs";
+      }
+    } else {
+      s += ns + "ns";
+    }
+  }
+  return neg ? "-" + s : s;
+};`;
+
+export const HELPER_SYNC = `var __sync_mutex = __sync_mutex || function() {
+  return { Lock() {}, Unlock() {}, TryLock() { return true; } };
+};
+var __sync_rwmutex = __sync_rwmutex || function() {
+  return { Lock() {}, Unlock() {}, RLock() {}, RUnlock() {}, TryLock() { return true; }, TryRLock() { return true; } };
+};
+var __sync_once = __sync_once || function() {
+  return { done: 0, Do(f) { if (!this.done) { this.done = 1; f(); } } };
+};
+var __sync_waitgroup = __sync_waitgroup || function() {
+  return { counter: 0, Add(d) { this.counter = (this.counter || 0) + d; }, Done() { this.counter = (this.counter || 0) - 1; }, Wait() {} };
+};`;
+
+export const HELPER_CRYPTO_RAND = `var __crypto_rand_read = __crypto_rand_read || function(b) {
+  if (!b || b.length === 0) return [0, null];
+  const u8 = ArrayBuffer.isView(b) ? b : new Uint8Array(b.length);
+  const c = typeof crypto !== "undefined" ? crypto : (typeof globalThis !== "undefined" ? globalThis.crypto : null);
+  const CHUNK = 65536;
+  if (c && typeof c.getRandomValues === "function") {
+    for (let offset = 0; offset < u8.length; offset += CHUNK) {
+      const slice = u8.subarray(offset, Math.min(offset + CHUNK, u8.length));
+      c.getRandomValues(slice);
+    }
+  } else {
+    for (let i = 0; i < u8.length; i++) u8[i] = Math.floor(Math.random() * 256);
+  }
+  if (!ArrayBuffer.isView(b)) {
+    for (let i = 0; i < u8.length; i++) b[i] = u8[i];
+  }
+  return [b.length, null];
+};
+var __crypto_rand_reader = __crypto_rand_reader || {
+  Read: function(b) { return __crypto_rand_read(b); }
+};`;
+
+export const HELPER_SHA256 = `var __sha256 = __sha256 || (function() {
+  const K = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+  ];
+  function rotr(x, n) { return (x >>> n) | (x << (32 - n)); }
+  function block(H, M) {
+    const W = new Int32Array(64);
+    for (let i = 0; i < 16; i++) {
+      W[i] = (M[i * 4] << 24) | (M[i * 4 + 1] << 16) | (M[i * 4 + 2] << 8) | M[i * 4 + 3];
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(W[i - 15], 7) ^ rotr(W[i - 15], 18) ^ (W[i - 15] >>> 3);
+      const s1 = rotr(W[i - 2], 17) ^ rotr(W[i - 2], 19) ^ (W[i - 2] >>> 10);
+      W[i] = (W[i - 16] + s0 + W[i - 7] + s1) | 0;
+    }
+    let [a, b, c, d, e, f, g, h] = H;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (h + S1 + ch + K[i] + W[i]) | 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (S0 + maj) | 0;
+      h = g; g = f; f = e; e = (d + t1) | 0;
+      d = c; c = b; b = a; a = (t1 + t2) | 0;
+    }
+    H[0] = (H[0] + a) | 0; H[1] = (H[1] + b) | 0; H[2] = (H[2] + c) | 0; H[3] = (H[3] + d) | 0;
+    H[4] = (H[4] + e) | 0; H[5] = (H[5] + f) | 0; H[6] = (H[6] + g) | 0; H[7] = (H[7] + h) | 0;
+  }
+  function digest(bytes) {
+    const H = new Int32Array([
+      0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+      0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    ]);
+    const len = bytes ? bytes.length : 0;
+    const padLen = (len % 64 < 56) ? (56 - (len % 64)) : (120 - (len % 64));
+    const total = len + padLen + 8;
+    const buf = new Uint8Array(total);
+    if (bytes) {
+      if (ArrayBuffer.isView(bytes)) buf.set(bytes);
+      else for (let i = 0; i < len; i++) buf[i] = bytes[i];
+    }
+    buf[len] = 0x80;
+    const bits = BigInt(len) * 8n;
+    for (let i = 0; i < 8; i++) {
+      buf[total - 1 - i] = Number((bits >> BigInt(i * 8)) & 0xffn);
+    }
+    for (let i = 0; i < total; i += 64) {
+      block(H, buf.subarray(i, i + 64));
+    }
+    const out = new Uint8Array(32);
+    for (let i = 0; i < 8; i++) {
+      out[i * 4] = (H[i] >>> 24) & 0xff;
+      out[i * 4 + 1] = (H[i] >>> 16) & 0xff;
+      out[i * 4 + 2] = (H[i] >>> 8) & 0xff;
+      out[i * 4 + 3] = H[i] & 0xff;
+    }
+    return out;
+  }
+  class Hash {
+    constructor() { this.Reset(); }
+    Reset() { this.buf = []; }
+    Write(p) {
+      if (p) {
+        for (let i = 0; i < p.length; i++) this.buf.push(p[i]);
+      }
+      return [p ? p.length : 0, null];
+    }
+    Sum(b) {
+      const d = digest(this.buf);
+      if (!b || b.length === 0) return d;
+      const res = new Uint8Array(b.length + d.length);
+      res.set(b, 0);
+      res.set(d, b.length);
+      return res;
+    }
+    Size() { return 32; }
+    BlockSize() { return 64; }
+  }
+  return {
+    Sum256: digest,
+    New: () => new Hash()
+  };
+})();`;
+
+export const HELPER_BINARY = `var __binary_le = __binary_le || {
+  Uint16: function(b) { return (b[0] | (b[1] << 8)) & 0xffff; },
+  Uint32: function(b) { return ((b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0); },
+  Uint64: function(b) {
+    const lo = BigInt((b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0);
+    const hi = BigInt((b[4] | (b[5] << 8) | (b[6] << 16) | (b[7] << 24)) >>> 0);
+    return Number(lo | (hi << 32n));
+  },
+  PutUint16: function(b, v) { b[0] = v & 0xff; b[1] = (v >> 8) & 0xff; },
+  PutUint32: function(b, v) { b[0] = v & 0xff; b[1] = (v >> 8) & 0xff; b[2] = (v >> 16) & 0xff; b[3] = (v >>> 24) & 0xff; },
+  PutUint64: function(b, v) {
+    const bv = BigInt(v);
+    for (let i = 0n; i < 8n; i++) b[Number(i)] = Number((bv >> (i * 8n)) & 0xffn);
+  },
+  AppendUint16: function(b, v) {
+    const len = b ? b.length : 0;
+    const res = new Uint8Array(len + 2);
+    if (len > 0) res.set(b, 0);
+    res[len] = v & 0xff;
+    res[len + 1] = (v >> 8) & 0xff;
+    return res;
+  },
+  AppendUint32: function(b, v) {
+    const len = b ? b.length : 0;
+    const res = new Uint8Array(len + 4);
+    if (len > 0) res.set(b, 0);
+    res[len] = v & 0xff;
+    res[len + 1] = (v >> 8) & 0xff;
+    res[len + 2] = (v >> 16) & 0xff;
+    res[len + 3] = (v >>> 24) & 0xff;
+    return res;
+  },
+  AppendUint64: function(b, v) {
+    const len = b ? b.length : 0;
+    const res = new Uint8Array(len + 8);
+    if (len > 0) res.set(b, 0);
+    const bv = BigInt(v);
+    for (let i = 0n; i < 8n; i++) res[len + Number(i)] = Number((bv >> (i * 8n)) & 0xffn);
+    return res;
+  },
+  String: function() { return "LittleEndian"; }
+};
+var __binary_be = __binary_be || {
+  Uint16: function(b) { return ((b[0] << 8) | b[1]) & 0xffff; },
+  Uint32: function(b) { return (((b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]) >>> 0); },
+  Uint64: function(b) {
+    const hi = BigInt(((b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]) >>> 0);
+    const lo = BigInt(((b[4] << 24) | (b[5] << 16) | (b[6] << 8) | b[7]) >>> 0);
+    return Number((hi << 32n) | lo);
+  },
+  PutUint16: function(b, v) { b[0] = (v >> 8) & 0xff; b[1] = v & 0xff; },
+  PutUint32: function(b, v) { b[0] = (v >>> 24) & 0xff; b[1] = (v >> 16) & 0xff; b[2] = (v >> 8) & 0xff; b[3] = v & 0xff; },
+  PutUint64: function(b, v) {
+    const bv = BigInt(v);
+    for (let i = 0n; i < 8n; i++) b[Number(7n - i)] = Number((bv >> (i * 8n)) & 0xffn);
+  },
+  AppendUint16: function(b, v) {
+    const len = b ? b.length : 0;
+    const res = new Uint8Array(len + 2);
+    if (len > 0) res.set(b, 0);
+    res[len] = (v >> 8) & 0xff;
+    res[len + 1] = v & 0xff;
+    return res;
+  },
+  AppendUint32: function(b, v) {
+    const len = b ? b.length : 0;
+    const res = new Uint8Array(len + 4);
+    if (len > 0) res.set(b, 0);
+    res[len] = (v >>> 24) & 0xff;
+    res[len + 1] = (v >> 16) & 0xff;
+    res[len + 2] = (v >> 8) & 0xff;
+    res[len + 3] = v & 0xff;
+    return res;
+  },
+  AppendUint64: function(b, v) {
+    const len = b ? b.length : 0;
+    const res = new Uint8Array(len + 8);
+    if (len > 0) res.set(b, 0);
+    const bv = BigInt(v);
+    for (let i = 0n; i < 8n; i++) res[len + Number(i)] = Number((bv >> ((7n - i) * 8n)) & 0xffn);
+    return res;
+  },
+  String: function() { return "BigEndian"; }
+};
+var __binary_size = __binary_size || function(v) {
+  if (typeof v === "number" || typeof v === "bigint") return 8;
+  if (Array.isArray(v) || ArrayBuffer.isView(v)) return v.length;
+  if (v && typeof v === "object") {
+    let s = 0;
+    for (const k of Object.keys(v)) { if (!k.startsWith("_") && typeof v[k] !== "function") s += __binary_size(v[k]); }
+    return s;
+  }
+  return -1;
+};
+var __binary_read = __binary_read || function(r, order, data, sz, typeTag) {
+  const targetR = r?.value ?? r;
+  const readChunk = function(buf) {
+    if (typeof targetR?.Read === "function") return targetR.Read(buf);
+    if (Array.isArray(targetR?._buf)) {
+      const n = Math.min(buf.length, targetR._buf.length);
+      for (let i = 0; i < n; i++) buf[i] = targetR._buf.shift();
+      return [n, n < buf.length ? __io_eof : null];
+    }
+    return [0, __error("binary.Read: unsupported reader")];
+  };
+  const isBox = data && typeof data === "object" && Object.prototype.hasOwnProperty.call(data, "value") && (data.__box === true || (Object.keys(data).length <= 2 && (data.constructor === Object || !data.constructor || data.constructor?.name === "Object")));
+  const target = isBox ? data : null;
+  if (!target && data && typeof data === "object" && !Array.isArray(data) && !ArrayBuffer.isView(data)) {
+    for (const k of Object.keys(data)) {
+      if (k.startsWith("_") || typeof data[k] === "function") continue;
+      const fBox = { value: data[k], __box: true };
+      const err = __binary_read(r, order, fBox);
+      if (err) return err;
+      data[k] = fBox.value;
+    }
+    return null;
+  }
+  const s = sz || (target ? (typeof target.value === "bigint" ? 8 : (typeof target.value === "number" ? 4 : 4)) : __binary_size(data?.value ?? data));
+  if (s <= 0) return __error("binary.Read: invalid type");
+  const buf = new Uint8Array(s);
+  const [n, err] = readChunk(buf);
+  if (err) return err;
+  if (n < s) return __io_eof;
+  if (target) {
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const isLe = order.String() === "LittleEndian";
+    if (typeTag === "float32") target.value = view.getFloat32(0, isLe);
+    else if (typeTag === "float64") target.value = view.getFloat64(0, isLe);
+    else if (typeTag === "int8") target.value = view.getInt8(0);
+    else if (typeTag === "uint8" || typeTag === "byte" || typeTag === "bool") target.value = view.getUint8(0);
+    else if (typeTag === "int16") target.value = view.getInt16(0, isLe);
+    else if (typeTag === "uint16") target.value = view.getUint16(0, isLe);
+    else if (typeTag === "int32" || typeTag === "rune") target.value = view.getInt32(0, isLe);
+    else if (typeTag === "uint32") target.value = view.getUint32(0, isLe);
+    else if (typeTag === "int64") target.value = Number(view.getBigInt64(0, isLe));
+    else if (typeTag === "uint64") target.value = Number(view.getBigUint64(0, isLe));
+    else if (s === 1) target.value = buf[0];
+    else if (s === 2) target.value = order.Uint16(buf);
+    else if (s === 4) target.value = order.Uint32(buf);
+    else if (s === 8) target.value = order.Uint64(buf);
+    return null;
+  }
+  if (Array.isArray(data) || ArrayBuffer.isView(data)) {
+    for (let i = 0; i < s; i++) data[i] = buf[i];
+    return null;
+  }
+  return null;
+};
+var __binary_write = __binary_write || function(w, order, data, sz, typeTag) {
+  const targetW = w?.value ?? w;
+  const writeChunk = function(chunk) {
+    if (typeof targetW?.Write === "function") return targetW.Write(chunk);
+    if (Array.isArray(targetW?._buf)) {
+      for (let i = 0; i < chunk.length; i++) targetW._buf.push(chunk[i]);
+      return [chunk.length, null];
+    }
+    if (typeof targetW?._buf === "string") {
+      targetW._buf += new TextDecoder().decode(chunk);
+      return [chunk.length, null];
+    }
+    return [0, __error("binary.Write: unsupported writer")];
+  };
+  const isBox = data && typeof data === "object" && Object.prototype.hasOwnProperty.call(data, "value") && (data.__box === true || (Object.keys(data).length <= 2 && (data.constructor === Object || !data.constructor || data.constructor?.name === "Object")));
+  const v = isBox ? data.value : data;
+  if (!isBox && typeof data === "object" && data !== null && !Array.isArray(data) && !ArrayBuffer.isView(data)) {
+    for (const k of Object.keys(data)) {
+      if (k.startsWith("_") || typeof data[k] === "function") continue;
+      const err = __binary_write(w, order, data[k]);
+      if (err) return err;
+    }
+    return null;
+  }
+  if (typeof v === "number" || typeof v === "bigint" || typeof v === "boolean") {
+    const s = sz || (typeof v === "bigint" ? 8 : (typeTag === "float64" ? 8 : 4));
+    const buf = new Uint8Array(s);
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const isLe = order.String() === "LittleEndian";
+    if (typeTag === "float32") view.setFloat32(0, Number(v), isLe);
+    else if (typeTag === "float64") view.setFloat64(0, Number(v), isLe);
+    else if (s === 1) buf[0] = Number(v) & 0xff;
+    else if (s === 2) order.PutUint16(buf, Number(v));
+    else if (s === 4) order.PutUint32(buf, Number(v));
+    else order.PutUint64(buf, v);
+    const [, err] = writeChunk(buf);
+    return err;
+  }
+  if (Array.isArray(v) || ArrayBuffer.isView(v)) {
+    const [, err] = writeChunk(v);
+    return err;
+  }
+  return __error("binary.Write: unsupported type");
+};`;
+
+export const HELPER_HEX = `var __hex_encode_to_string = __hex_encode_to_string || function(src) {
+  if (!src || src.length === 0) return "";
+  let s = "";
+  for (let i = 0; i < src.length; i++) s += src[i].toString(16).padStart(2, "0");
+  return s;
+};
+var __hex_decode_string = __hex_decode_string || function(s) {
+  if (s.length % 2 !== 0) return [new Uint8Array(0), __error("encoding/hex: odd length hex string")];
+  const out = new Uint8Array(s.length / 2);
+  for (let i = 0; i < s.length; i += 2) {
+    const pair = s.slice(i, i + 2);
+    if (!/^[0-9a-fA-F]{2}$/.test(pair)) {
+      return [out.subarray(0, i / 2), __error("encoding/hex: invalid byte: " + pair)];
+    }
+    out[i / 2] = parseInt(pair, 16);
+  }
+  return [out, null];
+};
+var __hex_encode = __hex_encode || function(dst, src) {
+  const hex = __hex_encode_to_string(src);
+  for (let i = 0; i < hex.length; i++) dst[i] = hex.charCodeAt(i);
+  return hex.length;
+};
+var __hex_decode = __hex_decode || function(dst, src) {
+  const str = typeof src === "string" ? src : (src instanceof Uint8Array ? new TextDecoder().decode(src) : String.fromCharCode(...src));
+  const [res, err] = __hex_decode_string(str);
+  for (let i = 0; i < res.length; i++) dst[i] = res[i];
+  return [res.length, err];
+};`;
+
+export const HELPER_BASE64 = `var __base64_make = __base64_make || function(alphabet, padChar) {
+  const encMap = alphabet.split("");
+  const decMap = {};
+  for (let i = 0; i < 64; i++) decMap[alphabet[i]] = i;
+  return {
+    EncodeToString: function(src) {
+      if (!src || src.length === 0) return "";
+      let res = "";
+      let i = 0;
+      for (; i + 2 < src.length; i += 3) {
+        const n = (src[i] << 16) | (src[i + 1] << 8) | src[i + 2];
+        res += encMap[(n >> 18) & 63] + encMap[(n >> 12) & 63] + encMap[(n >> 6) & 63] + encMap[n & 63];
+      }
+      if (i < src.length) {
+        if (src.length - i === 1) {
+          const n = src[i] << 16;
+          res += encMap[(n >> 18) & 63] + encMap[(n >> 12) & 63];
+          if (padChar) res += padChar + padChar;
+        } else {
+          const n = (src[i] << 16) | (src[i + 1] << 8);
+          res += encMap[(n >> 18) & 63] + encMap[(n >> 12) & 63] + encMap[(n >> 6) & 63];
+          if (padChar) res += padChar;
+        }
+      }
+      return res;
+    },
+    DecodeString: function(s) {
+      let str = s.replace(/\\s+/g, "");
+      if (padChar) {
+        if (str.length % 4 !== 0) return [new Uint8Array(0), __error("illegal base64 data at input byte " + str.length)];
+        if (str.endsWith(padChar + padChar)) {
+          if (str.endsWith(padChar + padChar + padChar)) return [new Uint8Array(0), __error("illegal base64 data at input byte " + (str.length - 3))];
+          str = str.slice(0, -2);
+          if (str.length % 4 !== 2) return [new Uint8Array(0), __error("illegal base64 data at input byte " + str.length)];
+        } else if (str.endsWith(padChar)) {
+          str = str.slice(0, -1);
+          if (str.length % 4 !== 3) return [new Uint8Array(0), __error("illegal base64 data at input byte " + str.length)];
+        }
+      }
+      const out = [];
+      let i = 0;
+      for (; i + 3 < str.length; i += 4) {
+        const c0 = decMap[str[i]], c1 = decMap[str[i+1]], c2 = decMap[str[i+2]], c3 = decMap[str[i+3]];
+        if (c0 === undefined || c1 === undefined || c2 === undefined || c3 === undefined) return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
+        const n = (c0 << 18) | (c1 << 12) | (c2 << 6) | c3;
+        out.push((n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff);
+      }
+      const rem = str.length - i;
+      if (rem === 2) {
+        const c0 = decMap[str[i]], c1 = decMap[str[i+1]];
+        if (c0 === undefined || c1 === undefined) return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
+        out.push((c0 << 2) | (c1 >> 4));
+      } else if (rem === 3) {
+        const c0 = decMap[str[i]], c1 = decMap[str[i+1]], c2 = decMap[str[i+2]];
+        if (c0 === undefined || c1 === undefined || c2 === undefined) return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
+        out.push((c0 << 2) | (c1 >> 4), ((c1 & 15) << 4) | (c2 >> 2));
+      } else if (rem === 1) {
+        return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
+      }
+      return [new Uint8Array(out), null];
+    },
+    Encode: function(dst, src) {
+      const s = this.EncodeToString(src);
+      for (let i = 0; i < s.length; i++) dst[i] = s.charCodeAt(i);
+    },
+    Decode: function(dst, src) {
+      const str = String.fromCharCode(...src);
+      const [res, err] = this.DecodeString(str);
+      for (let i = 0; i < res.length; i++) dst[i] = res[i];
+      return [res.length, err];
+    },
+    EncodedLen: function(n) { return padChar ? Math.ceil(n / 3) * 4 : Math.floor((n * 8 + 5) / 6); },
+    DecodedLen: function(n) { return padChar ? Math.floor(n * 3 / 4) : Math.floor(n * 6 / 8); },
+    WithPadding: function(p) { return __base64_make(alphabet, p === -1 ? "" : String.fromCharCode(p)); }
+  };
+};
+var __base64_std = __base64_std || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=");
+var __base64_url = __base64_url || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", "=");
+var __base64_raw_std = __base64_raw_std || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "");
+var __base64_raw_url = __base64_raw_url || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", "");`;