gofront 1.6.0 → 1.7.0

package/src/backend/js/runtime.js

@@ -43,15 +43,84 @@ 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;
 };`;
 
@@ -62,9 +131,21 @@ export const HELPER_NIL_CALL = `var __nilcall = __nilcall || function(x) {
   return x;
 };`;
 
+// Interface equality: named non-struct values are boxed in interfaces, so two
+// boxes are equal when they share a type and hold the same value (as in Go).
+export const HELPER_IFEQ = `var __ifeq = __ifeq || function(a, b) {
+  if (a === b) return true;
+  if (a === null || a === undefined || b === null || b === undefined) return a == null && b == null;
+  if (typeof a === "object" && typeof b === "object" && a.constructor === b.constructor && typeof a.__gfUnbox === "function") {
+    return a.__gfUnbox() === b.__gfUnbox();
+  }
+  return false;
+};`;
+
 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;
@@ -124,10 +205,124 @@ var __recover = __recover || function(ok) {
 
 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 (typeof val.__gfUnbox === "function") return formatV(val.__gfUnbox(), isPlus, isTopLevel);
+      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++];
+    let v = a[i++];
+    // Boxed named values format as their underlying value; Error() still applies to %v/%s/%q/%w.
+    if (v && typeof v.__gfUnbox === "function" && !(typeof v.Error === "function" && "vsqw".includes(verb))) v = v.__gfUnbox();
     const [, flags, width, prec] = m.match(/^%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)/) || [];
     const zero = flags?.includes("0") && !flags?.includes("-");
     const pad = (s, w, z) => {
@@ -138,30 +333,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); }
@@ -175,17 +386,95 @@ 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" && target !== null &&
+      typeof err.__gfUnbox === "function" && err.constructor === target.constructor &&
+      err.__gfUnbox() === target.__gfUnbox()) 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, extract) {
+  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 = extract ? extract(unboxed) : unboxed;
+      } else {
+        Object.assign(target, unboxed);
+      }
+      return true;
+    }
+    if (Array.isArray(cur._errs)) {
+      for (const sub of cur._errs) {
+        if (__errorAs(sub, target, matcher, extract)) 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, extract)) return true;
+        }
+      } else if (unwrapped !== null && unwrapped !== undefined) {
+        if (__errorAs(unwrapped, target, matcher, extract)) 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
@@ -222,6 +511,32 @@ var __strconv_parse_int = __strconv_parse_int || function(s, base, bits) {
   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];
@@ -264,37 +579,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;
     }
   });
@@ -306,7 +743,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 }];
   }
 };`;
 
@@ -425,3 +862,1030 @@ 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-_", "");`;
+
+export const HELPER_JSON = `var __json_esc = __json_esc || function(s) {
+  if (typeof s !== "string") s = String(s);
+  return JSON.stringify(s)
+    .replace(/[<>&]/g, function(c) {
+      return c === "<" ? "\\\\u003c" : (c === ">" ? "\\\\u003e" : "\\\\u0026");
+    })
+    .replace(/\\u2028/g, "\\\\u2028")
+    .replace(/\\u2029/g, "\\\\u2029");
+};
+var __json_err = __json_err || function(msg) {
+  return typeof __error === "function" ? __error("json: " + msg) : new Error("json: " + msg);
+};
+// Decode error context, as in Go: innermost struct being decoded plus the path
+// of JSON field names from the root. Reset by every __json_unmarshal call.
+var __json_structs = __json_structs || [];
+var __json_path = __json_path || [];
+var __json_ctx = __json_ctx || function(typeName) {
+  if (__json_path.length > 0 && __json_structs.length > 0) {
+    return "Go struct field " + __json_structs[__json_structs.length - 1] + "." + __json_path.join(".") + " of type " + typeName;
+  }
+  return "Go value of type " + typeName;
+};
+// The JSON source text of a number, for "cannot unmarshal number <literal>" messages.
+var __json_lit = __json_lit || function(v, raw) {
+  if (raw !== undefined && raw !== null) return String(raw).trim();
+  return typeof v === "string" ? v.replace(/__bigint$/, "") : String(v);
+};
+var __json_float_decode = __json_float_decode || function(v, bits, ctxType, raw) {
+  var n = __json_number_value(v);
+  if (typeof n !== "number") return __json_err("cannot unmarshal " + __json_type(v) + " into " + __json_ctx(ctxType));
+  var f = bits === 32 ? Math.fround(n) : n;
+  if (!isFinite(f)) return __json_err("cannot unmarshal number " + __json_lit(v, raw) + " into " + __json_ctx(ctxType));
+  return f;
+};
+// []byte accepts a base64 string or (like Go) an array of uint8 values.
+var __json_bytes_decode = __json_bytes_decode || function(v) {
+  if (Array.isArray(v)) {
+    var u8 = new Uint8Array(v.length);
+    for (var i = 0; i < v.length; i++) {
+      var b = __json_int_decode(v[i], "uint8", "uint8", __json_raw_child(v, i));
+      if (b && b._msg) return b;
+      u8[i] = b;
+    }
+    return u8;
+  }
+  if (typeof v !== "string") return __json_err("cannot unmarshal " + __json_type(v) + " into " + __json_ctx("[]uint8"));
+  return __json_b64_dec(v);
+};
+var __json_esc_noh = __json_esc_noh || function(s) {
+  return JSON.stringify(String(s)).replace(/\\u2028/g, "\\\\u2028").replace(/\\u2029/g, "\\\\u2029");
+};
+var __json_syntax_msg = __json_syntax_msg || function(s) {
+  var t = String(s).trim();
+  if (t === "") return "unexpected end of JSON input";
+  var m;
+  try { JSON.parse(t); } catch (e) { m = String(e && e.message); }
+  if (m && /end of JSON input|Unterminated/.test(m)) return "unexpected end of JSON input";
+  var pos = m && /after JSON at position (\\d+)/.exec(m);
+  if (pos) return "invalid character '" + t[Number(pos[1])] + "' after top-level value";
+  if ("{[\\"-0123456789tfn".indexOf(t[0]) < 0) return "invalid character '" + t[0] + "' looking for beginning of value";
+  return "invalid character in JSON value";
+};
+// Validates and compacts JSON text, escaping <, >, & and U+2028/U+2029 inside strings.
+var __json_compact = __json_compact || function(s) {
+  try { JSON.parse(s); } catch (e) { return null; }
+  var out = "", inStr = false, esc = false;
+  for (var i = 0; i < s.length; i++) {
+    var c = s[i];
+    if (inStr) {
+      if (esc) { esc = false; out += c; continue; }
+      if (c === "\\\\") { esc = true; out += c; continue; }
+      if (c === '"') inStr = false;
+      if (c === "<") out += "\\\\u003c";
+      else if (c === ">") out += "\\\\u003e";
+      else if (c === "&") out += "\\\\u0026";
+      else if (c === "\\u2028") out += "\\\\u2028";
+      else if (c === "\\u2029") out += "\\\\u2029";
+      else out += c;
+      continue;
+    }
+    if (c === '"') { inStr = true; out += c; continue; }
+    if (c === " " || c === "\\t" || c === "\\n" || c === "\\r") continue;
+    out += c;
+  }
+  return out;
+};
+var __json_marshaler_out = __json_marshaler_out || function(res, typeName) {
+  var err = res && res[1];
+  if (err) throw new Error("json: error calling MarshalJSON for type " + typeName + ": " + (typeof err.Error === "function" ? err.Error() : String(err)));
+  var b = res ? res[0] : null;
+  var s = b === null || b === undefined ? "" : (typeof b === "string" ? b : new TextDecoder().decode(b));
+  var c = __json_compact(s);
+  if (c === null) throw new Error("json: error calling MarshalJSON for type " + typeName + ": " + __json_syntax_msg(s));
+  return c;
+};
+// Keeps user errors returned by UnmarshalJSON intact while fitting the decoders'
+// "_msg"-tagged error protocol; __json_unmarshal unwraps __userErr.
+var __json_user_err = __json_user_err || function(e) {
+  if (e && e._msg !== undefined) return e;
+  return { _msg: e && typeof e.Error === "function" ? e.Error() : String(e), __userErr: e };
+};
+// Decodes the JSON string payload of a ,string field. Returns { v } or an error.
+var __json_unquote = __json_unquote || function(val, kind, typeStr) {
+  if (val === null) return { v: null, lit: "null" };
+  if (typeof val !== "string" || val.endsWith("__bigint")) {
+    return __json_err("invalid use of ,string struct tag, trying to unmarshal unquoted value into " + typeStr);
+  }
+  var invalid = function() {
+    return __json_err("invalid use of ,string struct tag, trying to unmarshal " + JSON.stringify(val) + " into " + typeStr);
+  };
+  var inner;
+  try { inner = JSON.parse(__json_preserve_int64(val)); } catch (e) {
+    if (kind !== "string" && kind !== "bool" && /^-?[0-9]/.test(val)) return __json_err("cannot unmarshal number " + val + " into " + __json_ctx(typeStr));
+    return invalid();
+  }
+  if (inner === null) return { v: null, lit: val };
+  if (kind === "string") return typeof inner === "string" ? { v: inner, lit: val } : invalid();
+  if (kind === "bool") return typeof inner === "number" ? invalid() : { v: inner, lit: val };
+  return typeof inner === "boolean" ? invalid() : { v: inner, lit: val };
+};
+var __json_type = __json_type || function(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  var t = typeof v;
+  if (t === "number" || t === "bigint") return "number";
+  if (t === "string") return "string";
+  if (t === "boolean") return "bool";
+  if (t === "object") return "object";
+  return t;
+};
+var __json_raw_index = __json_raw_index || new WeakMap();
+var __json_parse_raw_node = __json_parse_raw_node || function(s) {
+  var i = 0;
+  function ws() { while (i < s.length && /[\\t\\n\\r ]/.test(s[i])) i++; }
+  function stringEnd() {
+    i++;
+    while (i < s.length) {
+      if (s[i] === "\\\\") i += 2;
+      else if (s[i++] === '"') break;
+    }
+  }
+  function value() {
+    ws();
+    var start = i;
+    var node = { children: null };
+    if (s[i] === "{") {
+      i++;
+      node.children = new Map();
+      ws();
+      while (s[i] !== "}") {
+        var keyStart = i;
+        stringEnd();
+        var key = JSON.parse(s.slice(keyStart, i));
+        ws();
+        i++;
+        var child = value();
+        node.children.set(key, child);
+        ws();
+        if (s[i] === ",") { i++; ws(); }
+        else break;
+      }
+      i++;
+    } else if (s[i] === "[") {
+      i++;
+      node.children = new Map();
+      ws();
+      var index = 0;
+      while (s[i] !== "]") {
+        node.children.set(String(index++), value());
+        ws();
+        if (s[i] === ",") { i++; ws(); }
+        else break;
+      }
+      i++;
+    } else if (s[i] === '"') {
+      stringEnd();
+    } else {
+      while (i < s.length && !/[\\t\\n\\r ,}\\]]/.test(s[i])) i++;
+    }
+    node.raw = s.slice(start, i);
+    return node;
+  }
+  return value();
+};
+var __json_bind_raw = __json_bind_raw || function(value, node) {
+  if (value === null || typeof value !== "object" || !node?.children) return;
+  __json_raw_index.set(value, node.children);
+  for (const [key, child] of node.children) __json_bind_raw(value[key], child);
+};
+var __json_raw_child = __json_raw_child || function(parent, key) {
+  return __json_raw_index.get(parent)?.get(String(key))?.raw;
+};
+var __json_raw_bytes = __json_raw_bytes || function(raw) {
+  return new TextEncoder().encode(raw ?? "null");
+};
+var __json_match_field = __json_match_field || function(obj, tagName, fieldName) {
+  if (Object.prototype.hasOwnProperty.call(obj, tagName)) return tagName;
+  if (Object.prototype.hasOwnProperty.call(obj, fieldName)) return fieldName;
+  var tagFold = tagName.toLowerCase();
+  var fieldFold = fieldName.toLowerCase();
+  for (const key of Object.keys(obj)) {
+    var keyFold = key.toLowerCase();
+    if (keyFold === tagFold || keyFold === fieldFold) return key;
+  }
+  return null;
+};
+var __json_float32 = __json_float32 || function(v) {
+  var f = Math.fround(v);
+  if (!isFinite(f)) throw new Error("json: unsupported value: " + f);
+  if (Object.is(f, -0)) return "-0";
+  var candidate;
+  for (var precision = 1; precision <= 9; precision++) {
+    candidate = f.toPrecision(precision);
+    if (Math.fround(Number(candidate)) === f) break;
+  }
+  var n = Number(candidate);
+  var expText = n.toExponential();
+  var match = /e([+-]?)(\\d+)$/.exec(expText);
+  var exponent = Number(match[2]) * (match[1] === "-" ? -1 : 1);
+  if (exponent < -6 || exponent >= 21) {
+    var mantissa = expText.slice(0, expText.indexOf("e"));
+    var sign = exponent >= 0 ? "+" : "-";
+    return mantissa + "e" + sign + String(Math.abs(exponent));
+  }
+  return n.toString();
+};
+var __json_number_value = __json_number_value || function(v) {
+  return typeof v === "string" && v.endsWith("__bigint") ? Number(v.slice(0, -8)) : v;
+};
+var __json_int_decode = __json_int_decode || function(v, typeName, ctxType, raw) {
+  var type = typeof v === "string" && v.endsWith("__bigint") ? "number" : __json_type(v);
+  var fail = function() {
+    return __json_err("cannot unmarshal " + (type === "number" ? "number " + __json_lit(v, raw) : type) + " into " + __json_ctx(ctxType));
+  };
+  if (type !== "number") return fail();
+  // Go parses integers with strconv.ParseInt: "1.0" and "1e2" are not integers.
+  if (raw !== undefined && raw !== null && !/^-?(0|[1-9][0-9]*)$/.test(String(raw).trim())) return fail();
+  var integer;
+  var signed = typeName === "int" || typeName.startsWith("int");
+  if (typeName === "int64" || typeName === "uint64") {
+    if (typeof v === "string" && v.endsWith("__bigint")) {
+      try { integer = BigInt(v.slice(0, -8)); } catch (_) {}
+    } else if (typeof v === "number" && Number.isSafeInteger(v)) {
+      integer = BigInt(v);
+    }
+    if (integer !== undefined) {
+      var min64 = typeName === "int64" ? -(1n << 63n) : 0n;
+      var max64 = typeName === "int64" ? (1n << 63n) - 1n : (1n << 64n) - 1n;
+      if (integer >= min64 && integer <= max64) return typeof v === "number" ? v : integer;
+    }
+    return fail();
+  }
+  if (typeof v === "number" && Number.isSafeInteger(v)) {
+    if (typeName === "int") return v;
+    var bits = typeName === "uint" ? 53 : Number(typeName.replace(/^(u?int|byte|rune)/, ""));
+    if (!bits) bits = typeName === "byte" ? 8 : typeName === "rune" ? 32 : 53;
+    var min = signed ? -(2 ** (bits - 1)) : 0;
+    var max = signed ? (2 ** (bits - 1)) - 1 : (2 ** bits) - 1;
+    if (v >= min && v <= max) return v;
+  }
+  return fail();
+};
+var __json_b64 = __json_b64 || function(u8) {
+  if (u8 === null || u8 === undefined) return "null";
+  if (typeof __base64_std !== "undefined") return '"' + __base64_std.EncodeToString(u8) + '"';
+  var bstr = "";
+  for (var i = 0; i < u8.length; i++) bstr += String.fromCharCode(u8[i]);
+  return '"' + (typeof btoa !== "undefined" ? btoa(bstr) : Buffer.from(u8).toString("base64")) + '"';
+};
+var __json_b64_dec = __json_b64_dec || function(str) {
+  if (typeof __base64_std !== "undefined") {
+    var res = __base64_std.DecodeString(str);
+    if (!res[1]) return res[0];
+  }
+  var bin = typeof atob !== "undefined" ? atob(str) : Buffer.from(str, "base64").toString("binary");
+  var u8 = new Uint8Array(bin.length);
+  for (var i = 0; i < bin.length; i++) u8[i] = bin.charCodeAt(i);
+  return u8;
+};
+var __json_is_zero = __json_is_zero || function(val, isStruct) {
+  if (isStruct) return false;
+  if (val === null || val === undefined || val === false || val === 0 || val === "") return true;
+  if (typeof val === "bigint") return val === 0n;
+  if (Array.isArray(val) || (ArrayBuffer.isView(val) && !val.__raw)) return val.length === 0;
+  if (val instanceof Map) return val.size === 0;
+  if (val && val.__map) return Object.keys(val).filter(function(k) { return !k.startsWith("__"); }).length === 0;
+  return false;
+};
+var __json_preserve_int64 = __json_preserve_int64 || function(str) {
+  return str.replace(/"(?:\\\\.|[^"\\\\])*"|(?<=[,:\\[{\\s]|^)(-?\\d{16,})(?=[,\\]}\\s]|$)/g, function(m, num) {
+    if (num) {
+      try {
+        var b = BigInt(num);
+        if (b > 9007199254740991n || b < -9007199254740991n) return '"' + num + '__bigint"';
+      } catch (e) {}
+    }
+    return m;
+  });
+};
+var __json_enc_any = __json_enc_any || function(v) {
+  if (v === null || v === undefined) return "null";
+  var t = typeof v;
+  if (t === "boolean") return v ? "true" : "false";
+  if (t === "number") {
+    if (!isFinite(v)) throw new Error("json: unsupported value: " + v);
+    return String(v);
+  }
+  if (t === "bigint") return v.toString();
+  if (t === "string") return __json_esc(v);
+  if ((typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(v)) || v instanceof Uint8Array) {
+    if (v.__raw) {
+      var s = (typeof v === "string" ? v : new TextDecoder().decode(v)).trim();
+      return s.length > 0 ? s : "null";
+    }
+    return __json_b64(v);
+  }
+  if (Array.isArray(v)) {
+    var items = [];
+    for (var i = 0; i < v.length; i++) items.push(__json_enc_any(v[i]));
+    return "[" + items.join(",") + "]";
+  }
+  if (v instanceof Map) {
+    var mkeys = Array.from(v.keys()).map(String).sort();
+    var mentries = [];
+    for (var mi = 0; mi < mkeys.length; mi++) {
+      mentries.push(__json_esc(mkeys[mi]) + ":" + __json_enc_any(v.get(mkeys[mi])));
+    }
+    return "{" + mentries.join(",") + "}";
+  }
+  if (typeof v.__json_enc === "function") return v.__json_enc();
+  if (typeof v.MarshalJSON === "function" && !(v.__v === true && v.MarshalJSON.__ptrRecv)) {
+    return __json_marshaler_out(v.MarshalJSON(), v.constructor && v.constructor.name ? v.constructor.name : "value");
+  }
+  // Boxed named values (from an interface) encode as their value; *T boxes as the pointee.
+  if (typeof v.__gfUnbox === "function") {
+    var inner = v.__gfUnbox();
+    if (Object.prototype.hasOwnProperty.call(v, "_p")) inner = inner == null ? null : inner.value;
+    return __json_enc_any(inner);
+  }
+  if (typeof v === "object") {
+    var okeys = Object.keys(v).filter(function(k) { return !k.startsWith("__") || k === "__proto__"; });
+    if (!v.__map && v.constructor && v.constructor !== Object && v.constructor.name !== "Object") {
+      okeys = okeys.filter(function(k) { return !(k.length > 0 && k[0] >= "a" && k[0] <= "z"); });
+    }
+    okeys.sort();
+    var oentries = [];
+    for (var oi = 0; oi < okeys.length; oi++) {
+      oentries.push(__json_esc(okeys[oi]) + ":" + __json_enc_any(v[okeys[oi]]));
+    }
+    return "{" + oentries.join(",") + "}";
+  }
+  return "null";
+};
+var __json_dec_any = __json_dec_any || function(parsed) {
+  if (parsed === null) return null;
+  if (typeof parsed === "string") {
+    if (parsed.endsWith("__bigint")) return Number(parsed.slice(0, -8));
+    return parsed;
+  }
+  if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
+  if (Array.isArray(parsed)) {
+    var outSlice = [];
+    for (var i = 0; i < parsed.length; i++) outSlice.push(__json_dec_any(parsed[i]));
+    return outSlice;
+  }
+  if (typeof parsed === "object") {
+    var outMap = Object.create(null);
+    outMap.__map = true;
+    for (var k in parsed) {
+      if (Object.prototype.hasOwnProperty.call(parsed, k)) {
+        outMap[k] = __json_dec_any(parsed[k]);
+      }
+    }
+    return outMap;
+  }
+  return parsed;
+};
+var __json_dec_any_target = __json_dec_any_target || function(parsed, target, box) {
+  var out = __json_dec_any(parsed);
+  if (box) box.value = out;
+  else if (target && typeof target === "object") {
+    for (const k of Object.keys(out)) Object.defineProperty(target, k, { value: out[k], writable: true, enumerable: true, configurable: true });
+  }
+  return null;
+};
+var __json_enc_slice = __json_enc_slice || function(slice, elemEnc) {
+  if (slice === null || slice === undefined) return "null";
+  var items = [];
+  for (var i = 0; i < slice.length; i++) items.push(elemEnc(slice[i]));
+  return "[" + items.join(",") + "]";
+};
+var __json_enc_map = __json_enc_map || function(m, valEnc) {
+  if (m === null || m === undefined) return "null";
+  if (m instanceof Map) {
+    var mkeys = Array.from(m.keys()).map(String).sort();
+    var mentries = [];
+    for (var i = 0; i < mkeys.length; i++) {
+      mentries.push(__json_esc(mkeys[i]) + ":" + valEnc(m.get(mkeys[i])));
+    }
+    return "{" + mentries.join(",") + "}";
+  }
+  var keys = Object.keys(m).filter(function(k) { return !k.startsWith("__") || k === "__proto__"; }).sort();
+  var entries = [];
+  for (var j = 0; j < keys.length; j++) {
+    entries.push(__json_esc(keys[j]) + ":" + valEnc(m[keys[j]]));
+  }
+  return "{" + entries.join(",") + "}";
+};
+var __json_marshal = __json_marshal || function(enc, val) {
+  try {
+    var str = enc(val);
+    return [new TextEncoder().encode(str), null];
+  } catch (e) {
+    return [new Uint8Array(0), typeof __error === "function" ? __error(e.message) : e];
+  }
+};
+var __json_indent = __json_indent || function(jsonStr, prefix, indent) {
+  var out = "";
+  var depth = 0;
+  var inString = false;
+  var escaped = false;
+  for (var i = 0; i < jsonStr.length; i++) {
+    var c = jsonStr[i];
+    if (inString) {
+      out += c;
+      if (escaped) escaped = false;
+      else if (c === "\\\\") escaped = true;
+      else if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') { inString = true; out += c; continue; }
+    if (c === "{" || c === "[") {
+      out += c;
+      depth++;
+      var next = jsonStr[i + 1];
+      if ((c === "{" && next === "}") || (c === "[" && next === "]")) {
+        out += next;
+        i++;
+        depth--;
+        continue;
+      }
+      out += "\\n" + prefix + indent.repeat(depth);
+    } else if (c === "}" || c === "]") {
+      depth--;
+      out += "\\n" + prefix + indent.repeat(depth) + c;
+    } else if (c === ",") {
+      out += ",\\n" + prefix + indent.repeat(depth);
+    } else if (c === ":") {
+      out += ": ";
+    } else if (c !== " " && c !== "\\t" && c !== "\\n" && c !== "\\r") {
+      out += c;
+    }
+  }
+  return out;
+};
+var __json_marshal_indent = __json_marshal_indent || function(enc, val, prefix, indent) {
+  var res = __json_marshal(enc, val);
+  if (res[1]) return res;
+  var rawStr = new TextDecoder().decode(res[0]);
+  var formatted = __json_indent(rawStr, prefix, indent);
+  return [new TextEncoder().encode(formatted), null];
+};
+var __json_valid = __json_valid || function(data) {
+  try {
+    var s = typeof data === "string" ? data : new TextDecoder().decode(((typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(data)) || data instanceof Uint8Array) ? data : new Uint8Array(data));
+    JSON.parse(s);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+var __json_unmarshal = __json_unmarshal || function(dec, data, target) {
+  __json_structs.length = 0;
+  __json_path.length = 0;
+  if (target === null || target === undefined) {
+    return typeof __error === "function" ? __error("json: Unmarshal(nil)") : new Error("json: Unmarshal(nil)");
+  }
+  if (typeof target !== "object" || target.__v === true) {
+    return typeof __error === "function" ? __error("json: Unmarshal(non-pointer " + typeof target + ")") : new Error("json: Unmarshal(non-pointer " + typeof target + ")");
+  }
+  var str;
+  try {
+    str = typeof data === "string" ? data : new TextDecoder().decode(((typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(data)) || data instanceof Uint8Array) ? data : new Uint8Array(data));
+  } catch (e) {
+    return typeof __error === "function" ? __error("invalid UTF-8 data") : e;
+  }
+  var safeStr = __json_preserve_int64(str);
+  var parsed;
+  try {
+    parsed = JSON.parse(safeStr);
+  } catch (e) {
+    return typeof __error === "function" ? __error(e.message) : e;
+  }
+  var rootRaw = __json_parse_raw_node(str);
+  __json_bind_raw(parsed, rootRaw);
+  var isBox = target && typeof target === "object" && (Object.prototype.hasOwnProperty.call(target, "value") || typeof target.__gfUnbox === "function");
+  var dest = isBox ? target.value : target;
+  var err = dec(parsed, dest, isBox ? target : null, data, rootRaw.raw);
+  if (err) return err.__userErr || err;
+  return null;
+};`;
+
+export const HELPER_SIMD = `var __simd_f32x4 = __simd_f32x4 || function(a, b, c, d) {
+  return Object.freeze([Math.fround(Number(a ?? 0)), Math.fround(Number(b ?? 0)), Math.fround(Number(c ?? 0)), Math.fround(Number(d ?? 0))]);
+};
+var __simd_splat = __simd_splat || function(v) {
+  var s = Math.fround(Number(v ?? 0));
+  return Object.freeze([s, s, s, s]);
+};
+var __simd_add = __simd_add || function(a, b) {
+  return Object.freeze([Math.fround(a[0] + b[0]), Math.fround(a[1] + b[1]), Math.fround(a[2] + b[2]), Math.fround(a[3] + b[3])]);
+};
+var __simd_sub = __simd_sub || function(a, b) {
+  return Object.freeze([Math.fround(a[0] - b[0]), Math.fround(a[1] - b[1]), Math.fround(a[2] - b[2]), Math.fround(a[3] - b[3])]);
+};
+var __simd_mul = __simd_mul || function(a, b) {
+  return Object.freeze([Math.fround(a[0] * b[0]), Math.fround(a[1] * b[1]), Math.fround(a[2] * b[2]), Math.fround(a[3] * b[3])]);
+};
+var __simd_div = __simd_div || function(a, b) {
+  return Object.freeze([Math.fround(a[0] / b[0]), Math.fround(a[1] / b[1]), Math.fround(a[2] / b[2]), Math.fround(a[3] / b[3])]);
+};
+var __simd_min = __simd_min || function(a, b) {
+  return Object.freeze([Math.fround(Math.min(a[0], b[0])), Math.fround(Math.min(a[1], b[1])), Math.fround(Math.min(a[2], b[2])), Math.fround(Math.min(a[3], b[3]))]);
+};
+var __simd_max = __simd_max || function(a, b) {
+  return Object.freeze([Math.fround(Math.max(a[0], b[0])), Math.fround(Math.max(a[1], b[1])), Math.fround(Math.max(a[2], b[2])), Math.fround(Math.max(a[3], b[3]))]);
+};
+var __simd_dot3 = __simd_dot3 || function(a, b) {
+  return Math.fround(Math.fround(Math.fround(a[0] * b[0]) + Math.fround(a[1] * b[1])) + Math.fround(a[2] * b[2]));
+};
+var __simd_dot4 = __simd_dot4 || function(a, b) {
+  return Math.fround(Math.fround(Math.fround(Math.fround(a[0] * b[0]) + Math.fround(a[1] * b[1])) + Math.fround(a[2] * b[2])) + Math.fround(a[3] * b[3]));
+};
+var __simd_with_lane = __simd_with_lane || function(a, i, v) {
+  var r = [a[0], a[1], a[2], a[3]];
+  r[i] = Math.fround(v);
+  return Object.freeze(r);
+};
+var __simd_load = __simd_load || function(buf, i) {
+  if (i < 0 || i + 4 > buf.length) throw new Error("panic: runtime error: index out of range");
+  return Object.freeze([Math.fround(buf[i]), Math.fround(buf[i + 1]), Math.fround(buf[i + 2]), Math.fround(buf[i + 3])]);
+};
+var __simd_store = __simd_store || function(buf, i, v) {
+  if (i < 0 || i + 4 > buf.length) throw new Error("panic: runtime error: index out of range");
+  buf[i] = v[0]; buf[i + 1] = v[1]; buf[i + 2] = v[2]; buf[i + 3] = v[3];
+};`;