clauderan 0.1.0

package/dist/index.js

@@ -0,0 +1,2828 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/sql.js/dist/sql-wasm.js
+var require_sql_wasm = __commonJS((exports, module) => {
+  var __dirname = "/Users/michaelliv/Projects/clauderan/node_modules/sql.js/dist";
+  var initSqlJsPromise = undefined;
+  var initSqlJs = function(moduleConfig) {
+    if (initSqlJsPromise) {
+      return initSqlJsPromise;
+    }
+    initSqlJsPromise = new Promise(function(resolveModule, reject) {
+      var Module = typeof moduleConfig !== "undefined" ? moduleConfig : {};
+      var originalOnAbortFunction = Module["onAbort"];
+      Module["onAbort"] = function(errorThatCausedAbort) {
+        reject(new Error(errorThatCausedAbort));
+        if (originalOnAbortFunction) {
+          originalOnAbortFunction(errorThatCausedAbort);
+        }
+      };
+      Module["postRun"] = Module["postRun"] || [];
+      Module["postRun"].push(function() {
+        resolveModule(Module);
+      });
+      module = undefined;
+      var f;
+      f ||= typeof Module != "undefined" ? Module : {};
+      var aa = typeof window == "object", ba = typeof WorkerGlobalScope != "undefined", ca = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
+      f.onRuntimeInitialized = function() {
+        function a(g, l) {
+          switch (typeof l) {
+            case "boolean":
+              dc(g, l ? 1 : 0);
+              break;
+            case "number":
+              ec(g, l);
+              break;
+            case "string":
+              fc(g, l, -1, -1);
+              break;
+            case "object":
+              if (l === null)
+                lb(g);
+              else if (l.length != null) {
+                var n = da(l, ea);
+                gc(g, n, l.length, -1);
+                fa(n);
+              } else
+                va(g, "Wrong API use : tried to return a value of an unknown type (" + l + ").", -1);
+              break;
+            default:
+              lb(g);
+          }
+        }
+        function b(g, l) {
+          for (var n = [], r = 0;r < g; r += 1) {
+            var t = m(l + 4 * r, "i32"), y = hc(t);
+            if (y === 1 || y === 2)
+              t = ic(t);
+            else if (y === 3)
+              t = jc(t);
+            else if (y === 4) {
+              y = t;
+              t = kc(y);
+              y = lc(y);
+              for (var L = new Uint8Array(t), J = 0;J < t; J += 1)
+                L[J] = p[y + J];
+              t = L;
+            } else
+              t = null;
+            n.push(t);
+          }
+          return n;
+        }
+        function c(g, l) {
+          this.Qa = g;
+          this.db = l;
+          this.Oa = 1;
+          this.lb = [];
+        }
+        function d(g, l) {
+          this.db = l;
+          l = ha(g) + 1;
+          this.eb = ia(l);
+          if (this.eb === null)
+            throw Error("Unable to allocate memory for the SQL string");
+          u(g, x, this.eb, l);
+          this.kb = this.eb;
+          this.Za = this.pb = null;
+        }
+        function e(g) {
+          this.filename = "dbfile_" + (4294967295 * Math.random() >>> 0);
+          if (g != null) {
+            var l = this.filename, n = "/", r = l;
+            n && (n = typeof n == "string" ? n : ja(n), r = l ? ka(n + "/" + l) : n);
+            l = la(true, true);
+            r = ma(r, l);
+            if (g) {
+              if (typeof g == "string") {
+                n = Array(g.length);
+                for (var t = 0, y = g.length;t < y; ++t)
+                  n[t] = g.charCodeAt(t);
+                g = n;
+              }
+              na(r, l | 146);
+              n = oa(r, 577);
+              pa(n, g, 0, g.length, 0);
+              qa(n);
+              na(r, l);
+            }
+          }
+          this.handleError(q(this.filename, h));
+          this.db = m(h, "i32");
+          ob(this.db);
+          this.fb = {};
+          this.Sa = {};
+        }
+        var h = z(4), k = f.cwrap, q = k("sqlite3_open", "number", ["string", "number"]), w = k("sqlite3_close_v2", "number", ["number"]), v = k("sqlite3_exec", "number", ["number", "string", "number", "number", "number"]), C = k("sqlite3_changes", "number", ["number"]), G = k("sqlite3_prepare_v2", "number", ["number", "string", "number", "number", "number"]), pb = k("sqlite3_sql", "string", ["number"]), nc = k("sqlite3_normalized_sql", "string", ["number"]), qb = k("sqlite3_prepare_v2", "number", ["number", "number", "number", "number", "number"]), oc = k("sqlite3_bind_text", "number", ["number", "number", "number", "number", "number"]), rb = k("sqlite3_bind_blob", "number", ["number", "number", "number", "number", "number"]), pc = k("sqlite3_bind_double", "number", ["number", "number", "number"]), qc = k("sqlite3_bind_int", "number", ["number", "number", "number"]), rc = k("sqlite3_bind_parameter_index", "number", ["number", "string"]), sc = k("sqlite3_step", "number", ["number"]), tc = k("sqlite3_errmsg", "string", ["number"]), uc = k("sqlite3_column_count", "number", ["number"]), vc = k("sqlite3_data_count", "number", ["number"]), wc = k("sqlite3_column_double", "number", ["number", "number"]), sb = k("sqlite3_column_text", "string", ["number", "number"]), xc = k("sqlite3_column_blob", "number", ["number", "number"]), yc = k("sqlite3_column_bytes", "number", [
+          "number",
+          "number"
+        ]), zc = k("sqlite3_column_type", "number", ["number", "number"]), Ac = k("sqlite3_column_name", "string", ["number", "number"]), Bc = k("sqlite3_reset", "number", ["number"]), Cc = k("sqlite3_clear_bindings", "number", ["number"]), Dc = k("sqlite3_finalize", "number", ["number"]), tb = k("sqlite3_create_function_v2", "number", "number string number number number number number number number".split(" ")), hc = k("sqlite3_value_type", "number", ["number"]), kc = k("sqlite3_value_bytes", "number", ["number"]), jc = k("sqlite3_value_text", "string", ["number"]), lc = k("sqlite3_value_blob", "number", ["number"]), ic = k("sqlite3_value_double", "number", ["number"]), ec = k("sqlite3_result_double", "", ["number", "number"]), lb = k("sqlite3_result_null", "", ["number"]), fc = k("sqlite3_result_text", "", ["number", "string", "number", "number"]), gc = k("sqlite3_result_blob", "", ["number", "number", "number", "number"]), dc = k("sqlite3_result_int", "", ["number", "number"]), va = k("sqlite3_result_error", "", ["number", "string", "number"]), ub = k("sqlite3_aggregate_context", "number", ["number", "number"]), ob = k("RegisterExtensionFunctions", "number", ["number"]), vb = k("sqlite3_update_hook", "number", ["number", "number", "number"]);
+        c.prototype.bind = function(g) {
+          if (!this.Qa)
+            throw "Statement closed";
+          this.reset();
+          return Array.isArray(g) ? this.Cb(g) : g != null && typeof g === "object" ? this.Db(g) : true;
+        };
+        c.prototype.step = function() {
+          if (!this.Qa)
+            throw "Statement closed";
+          this.Oa = 1;
+          var g = sc(this.Qa);
+          switch (g) {
+            case 100:
+              return true;
+            case 101:
+              return false;
+            default:
+              throw this.db.handleError(g);
+          }
+        };
+        c.prototype.wb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          return wc(this.Qa, g);
+        };
+        c.prototype.Gb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          g = sb(this.Qa, g);
+          if (typeof BigInt !== "function")
+            throw Error("BigInt is not supported");
+          return BigInt(g);
+        };
+        c.prototype.Hb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          return sb(this.Qa, g);
+        };
+        c.prototype.getBlob = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          var l = yc(this.Qa, g);
+          g = xc(this.Qa, g);
+          for (var n = new Uint8Array(l), r = 0;r < l; r += 1)
+            n[r] = p[g + r];
+          return n;
+        };
+        c.prototype.get = function(g, l) {
+          l = l || {};
+          g != null && this.bind(g) && this.step();
+          g = [];
+          for (var n = vc(this.Qa), r = 0;r < n; r += 1)
+            switch (zc(this.Qa, r)) {
+              case 1:
+                var t = l.useBigInt ? this.Gb(r) : this.wb(r);
+                g.push(t);
+                break;
+              case 2:
+                g.push(this.wb(r));
+                break;
+              case 3:
+                g.push(this.Hb(r));
+                break;
+              case 4:
+                g.push(this.getBlob(r));
+                break;
+              default:
+                g.push(null);
+            }
+          return g;
+        };
+        c.prototype.getColumnNames = function() {
+          for (var g = [], l = uc(this.Qa), n = 0;n < l; n += 1)
+            g.push(Ac(this.Qa, n));
+          return g;
+        };
+        c.prototype.getAsObject = function(g, l) {
+          g = this.get(g, l);
+          l = this.getColumnNames();
+          for (var n = {}, r = 0;r < l.length; r += 1)
+            n[l[r]] = g[r];
+          return n;
+        };
+        c.prototype.getSQL = function() {
+          return pb(this.Qa);
+        };
+        c.prototype.getNormalizedSQL = function() {
+          return nc(this.Qa);
+        };
+        c.prototype.run = function(g) {
+          g != null && this.bind(g);
+          this.step();
+          return this.reset();
+        };
+        c.prototype.sb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          g = ra(g);
+          var n = da(g, ea);
+          this.lb.push(n);
+          this.db.handleError(oc(this.Qa, l, n, g.length - 1, 0));
+        };
+        c.prototype.Bb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          var n = da(g, ea);
+          this.lb.push(n);
+          this.db.handleError(rb(this.Qa, l, n, g.length, 0));
+        };
+        c.prototype.rb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          this.db.handleError((g === (g | 0) ? qc : pc)(this.Qa, l, g));
+        };
+        c.prototype.Eb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          rb(this.Qa, g, 0, 0, 0);
+        };
+        c.prototype.tb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          switch (typeof g) {
+            case "string":
+              this.sb(g, l);
+              return;
+            case "number":
+              this.rb(g, l);
+              return;
+            case "bigint":
+              this.sb(g.toString(), l);
+              return;
+            case "boolean":
+              this.rb(g + 0, l);
+              return;
+            case "object":
+              if (g === null) {
+                this.Eb(l);
+                return;
+              }
+              if (g.length != null) {
+                this.Bb(g, l);
+                return;
+              }
+          }
+          throw "Wrong API use : tried to bind a value of an unknown type (" + g + ").";
+        };
+        c.prototype.Db = function(g) {
+          var l = this;
+          Object.keys(g).forEach(function(n) {
+            var r = rc(l.Qa, n);
+            r !== 0 && l.tb(g[n], r);
+          });
+          return true;
+        };
+        c.prototype.Cb = function(g) {
+          for (var l = 0;l < g.length; l += 1)
+            this.tb(g[l], l + 1);
+          return true;
+        };
+        c.prototype.reset = function() {
+          this.freemem();
+          return Cc(this.Qa) === 0 && Bc(this.Qa) === 0;
+        };
+        c.prototype.freemem = function() {
+          for (var g;(g = this.lb.pop()) !== undefined; )
+            fa(g);
+        };
+        c.prototype.free = function() {
+          this.freemem();
+          var g = Dc(this.Qa) === 0;
+          delete this.db.fb[this.Qa];
+          this.Qa = 0;
+          return g;
+        };
+        d.prototype.next = function() {
+          if (this.eb === null)
+            return { done: true };
+          this.Za !== null && (this.Za.free(), this.Za = null);
+          if (!this.db.db)
+            throw this.mb(), Error("Database closed");
+          var g = sa(), l = z(4);
+          ta(h);
+          ta(l);
+          try {
+            this.db.handleError(qb(this.db.db, this.kb, -1, h, l));
+            this.kb = m(l, "i32");
+            var n = m(h, "i32");
+            if (n === 0)
+              return this.mb(), { done: true };
+            this.Za = new c(n, this.db);
+            this.db.fb[n] = this.Za;
+            return { value: this.Za, done: false };
+          } catch (r) {
+            throw this.pb = ua(this.kb), this.mb(), r;
+          } finally {
+            wa(g);
+          }
+        };
+        d.prototype.mb = function() {
+          fa(this.eb);
+          this.eb = null;
+        };
+        d.prototype.getRemainingSQL = function() {
+          return this.pb !== null ? this.pb : ua(this.kb);
+        };
+        typeof Symbol === "function" && typeof Symbol.iterator === "symbol" && (d.prototype[Symbol.iterator] = function() {
+          return this;
+        });
+        e.prototype.run = function(g, l) {
+          if (!this.db)
+            throw "Database closed";
+          if (l) {
+            g = this.prepare(g, l);
+            try {
+              g.step();
+            } finally {
+              g.free();
+            }
+          } else
+            this.handleError(v(this.db, g, 0, 0, h));
+          return this;
+        };
+        e.prototype.exec = function(g, l, n) {
+          if (!this.db)
+            throw "Database closed";
+          var r = sa(), t = null;
+          try {
+            var y = xa(g), L = z(4);
+            for (g = [];m(y, "i8") !== 0; ) {
+              ta(h);
+              ta(L);
+              this.handleError(qb(this.db, y, -1, h, L));
+              var J = m(h, "i32");
+              y = m(L, "i32");
+              if (J !== 0) {
+                var I = null;
+                t = new c(J, this);
+                for (l != null && t.bind(l);t.step(); )
+                  I === null && (I = { columns: t.getColumnNames(), values: [] }, g.push(I)), I.values.push(t.get(null, n));
+                t.free();
+              }
+            }
+            return g;
+          } catch (M) {
+            throw t && t.free(), M;
+          } finally {
+            wa(r);
+          }
+        };
+        e.prototype.each = function(g, l, n, r, t) {
+          typeof l === "function" && (r = n, n = l, l = undefined);
+          g = this.prepare(g, l);
+          try {
+            for (;g.step(); )
+              n(g.getAsObject(null, t));
+          } finally {
+            g.free();
+          }
+          if (typeof r === "function")
+            return r();
+        };
+        e.prototype.prepare = function(g, l) {
+          ta(h);
+          this.handleError(G(this.db, g, -1, h, 0));
+          g = m(h, "i32");
+          if (g === 0)
+            throw "Nothing to prepare";
+          var n = new c(g, this);
+          l != null && n.bind(l);
+          return this.fb[g] = n;
+        };
+        e.prototype.iterateStatements = function(g) {
+          return new d(g, this);
+        };
+        e.prototype["export"] = function() {
+          Object.values(this.fb).forEach(function(l) {
+            l.free();
+          });
+          Object.values(this.Sa).forEach(A);
+          this.Sa = {};
+          this.handleError(w(this.db));
+          var g = ya(this.filename);
+          this.handleError(q(this.filename, h));
+          this.db = m(h, "i32");
+          ob(this.db);
+          return g;
+        };
+        e.prototype.close = function() {
+          this.db !== null && (Object.values(this.fb).forEach(function(g) {
+            g.free();
+          }), Object.values(this.Sa).forEach(A), this.Sa = {}, this.Ya && (A(this.Ya), this.Ya = undefined), this.handleError(w(this.db)), za("/" + this.filename), this.db = null);
+        };
+        e.prototype.handleError = function(g) {
+          if (g === 0)
+            return null;
+          g = tc(this.db);
+          throw Error(g);
+        };
+        e.prototype.getRowsModified = function() {
+          return C(this.db);
+        };
+        e.prototype.create_function = function(g, l) {
+          Object.prototype.hasOwnProperty.call(this.Sa, g) && (A(this.Sa[g]), delete this.Sa[g]);
+          var n = Aa(function(r, t, y) {
+            t = b(t, y);
+            try {
+              var L = l.apply(null, t);
+            } catch (J) {
+              va(r, J, -1);
+              return;
+            }
+            a(r, L);
+          }, "viii");
+          this.Sa[g] = n;
+          this.handleError(tb(this.db, g, l.length, 1, 0, n, 0, 0, 0));
+          return this;
+        };
+        e.prototype.create_aggregate = function(g, l) {
+          var n = l.init || function() {
+            return null;
+          }, r = l.finalize || function(I) {
+            return I;
+          }, t = l.step;
+          if (!t)
+            throw "An aggregate function must have a step function in " + g;
+          var y = {};
+          Object.hasOwnProperty.call(this.Sa, g) && (A(this.Sa[g]), delete this.Sa[g]);
+          l = g + "__finalize";
+          Object.hasOwnProperty.call(this.Sa, l) && (A(this.Sa[l]), delete this.Sa[l]);
+          var L = Aa(function(I, M, Ra) {
+            var X = ub(I, 1);
+            Object.hasOwnProperty.call(y, X) || (y[X] = n());
+            M = b(M, Ra);
+            M = [y[X]].concat(M);
+            try {
+              y[X] = t.apply(null, M);
+            } catch (Fc) {
+              delete y[X], va(I, Fc, -1);
+            }
+          }, "viii"), J = Aa(function(I) {
+            var M = ub(I, 1);
+            try {
+              var Ra = r(y[M]);
+            } catch (X) {
+              delete y[M];
+              va(I, X, -1);
+              return;
+            }
+            a(I, Ra);
+            delete y[M];
+          }, "vi");
+          this.Sa[g] = L;
+          this.Sa[l] = J;
+          this.handleError(tb(this.db, g, t.length - 1, 1, 0, 0, L, J, 0));
+          return this;
+        };
+        e.prototype.updateHook = function(g) {
+          this.Ya && (vb(this.db, 0, 0), A(this.Ya), this.Ya = undefined);
+          g && (this.Ya = Aa(function(l, n, r, t, y) {
+            switch (n) {
+              case 18:
+                l = "insert";
+                break;
+              case 23:
+                l = "update";
+                break;
+              case 9:
+                l = "delete";
+                break;
+              default:
+                throw "unknown operationCode in updateHook callback: " + n;
+            }
+            r = r ? B(x, r) : "";
+            t = t ? B(x, t) : "";
+            if (y > Number.MAX_SAFE_INTEGER)
+              throw "rowId too big to fit inside a Number";
+            g(l, r, t, Number(y));
+          }, "viiiij"), vb(this.db, this.Ya, 0));
+        };
+        f.Database = e;
+      };
+      var Ba = { ...f }, Ca = "./this.program", Da = (a, b) => {
+        throw b;
+      }, D = "", Ea, Fa;
+      if (ca) {
+        var fs = __require("fs");
+        __require("path");
+        D = __dirname + "/";
+        Fa = (a) => {
+          a = Ga(a) ? new URL(a) : a;
+          return fs.readFileSync(a);
+        };
+        Ea = async (a) => {
+          a = Ga(a) ? new URL(a) : a;
+          return fs.readFileSync(a, undefined);
+        };
+        !f.thisProgram && 1 < process.argv.length && (Ca = process.argv[1].replace(/\\/g, "/"));
+        process.argv.slice(2);
+        typeof module != "undefined" && (module.exports = f);
+        Da = (a, b) => {
+          process.exitCode = a;
+          throw b;
+        };
+      } else if (aa || ba)
+        ba ? D = self.location.href : typeof document != "undefined" && document.currentScript && (D = document.currentScript.src), D = D.startsWith("blob:") ? "" : D.slice(0, D.replace(/[?#].*/, "").lastIndexOf("/") + 1), ba && (Fa = (a) => {
+          var b = new XMLHttpRequest;
+          b.open("GET", a, false);
+          b.responseType = "arraybuffer";
+          b.send(null);
+          return new Uint8Array(b.response);
+        }), Ea = async (a) => {
+          if (Ga(a))
+            return new Promise((c, d) => {
+              var e = new XMLHttpRequest;
+              e.open("GET", a, true);
+              e.responseType = "arraybuffer";
+              e.onload = () => {
+                e.status == 200 || e.status == 0 && e.response ? c(e.response) : d(e.status);
+              };
+              e.onerror = d;
+              e.send(null);
+            });
+          var b = await fetch(a, { credentials: "same-origin" });
+          if (b.ok)
+            return b.arrayBuffer();
+          throw Error(b.status + " : " + b.url);
+        };
+      var Ha = f.print || console.log.bind(console), Ia = f.printErr || console.error.bind(console);
+      Object.assign(f, Ba);
+      Ba = null;
+      f.thisProgram && (Ca = f.thisProgram);
+      var Ja = f.wasmBinary, Ka, La = false, Ma, p, x, Na, E, F, Oa, H, Pa, Ga = (a) => a.startsWith("file://");
+      function Qa() {
+        var a = Ka.buffer;
+        f.HEAP8 = p = new Int8Array(a);
+        f.HEAP16 = Na = new Int16Array(a);
+        f.HEAPU8 = x = new Uint8Array(a);
+        f.HEAPU16 = new Uint16Array(a);
+        f.HEAP32 = E = new Int32Array(a);
+        f.HEAPU32 = F = new Uint32Array(a);
+        f.HEAPF32 = Oa = new Float32Array(a);
+        f.HEAPF64 = Pa = new Float64Array(a);
+        f.HEAP64 = H = new BigInt64Array(a);
+        f.HEAPU64 = new BigUint64Array(a);
+      }
+      var K = 0, Sa = null;
+      function Ta(a) {
+        f.onAbort?.(a);
+        a = "Aborted(" + a + ")";
+        Ia(a);
+        La = true;
+        throw new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");
+      }
+      var Ua;
+      async function Va(a) {
+        if (!Ja)
+          try {
+            var b = await Ea(a);
+            return new Uint8Array(b);
+          } catch {}
+        if (a == Ua && Ja)
+          a = new Uint8Array(Ja);
+        else if (Fa)
+          a = Fa(a);
+        else
+          throw "both async and sync fetching of the wasm failed";
+        return a;
+      }
+      async function Wa(a, b) {
+        try {
+          var c = await Va(a);
+          return await WebAssembly.instantiate(c, b);
+        } catch (d) {
+          Ia(`failed to asynchronously prepare wasm: ${d}`), Ta(d);
+        }
+      }
+      async function Xa(a) {
+        var b = Ua;
+        if (!Ja && typeof WebAssembly.instantiateStreaming == "function" && !Ga(b) && !ca)
+          try {
+            var c = fetch(b, { credentials: "same-origin" });
+            return await WebAssembly.instantiateStreaming(c, a);
+          } catch (d) {
+            Ia(`wasm streaming compile failed: ${d}`), Ia("falling back to ArrayBuffer instantiation");
+          }
+        return Wa(b, a);
+      }
+
+      class Ya {
+        name = "ExitStatus";
+        constructor(a) {
+          this.message = `Program terminated with exit(${a})`;
+          this.status = a;
+        }
+      }
+      var Za = (a) => {
+        for (;0 < a.length; )
+          a.shift()(f);
+      }, $a = [], ab = [], bb = () => {
+        var a = f.preRun.shift();
+        ab.unshift(a);
+      };
+      function m(a, b = "i8") {
+        b.endsWith("*") && (b = "*");
+        switch (b) {
+          case "i1":
+            return p[a];
+          case "i8":
+            return p[a];
+          case "i16":
+            return Na[a >> 1];
+          case "i32":
+            return E[a >> 2];
+          case "i64":
+            return H[a >> 3];
+          case "float":
+            return Oa[a >> 2];
+          case "double":
+            return Pa[a >> 3];
+          case "*":
+            return F[a >> 2];
+          default:
+            Ta(`invalid type for getValue: ${b}`);
+        }
+      }
+      var cb = f.noExitRuntime || true;
+      function ta(a) {
+        var b = "i32";
+        b.endsWith("*") && (b = "*");
+        switch (b) {
+          case "i1":
+            p[a] = 0;
+            break;
+          case "i8":
+            p[a] = 0;
+            break;
+          case "i16":
+            Na[a >> 1] = 0;
+            break;
+          case "i32":
+            E[a >> 2] = 0;
+            break;
+          case "i64":
+            H[a >> 3] = BigInt(0);
+            break;
+          case "float":
+            Oa[a >> 2] = 0;
+            break;
+          case "double":
+            Pa[a >> 3] = 0;
+            break;
+          case "*":
+            F[a >> 2] = 0;
+            break;
+          default:
+            Ta(`invalid type for setValue: ${b}`);
+        }
+      }
+      var db = typeof TextDecoder != "undefined" ? new TextDecoder : undefined, B = (a, b = 0, c = NaN) => {
+        var d = b + c;
+        for (c = b;a[c] && !(c >= d); )
+          ++c;
+        if (16 < c - b && a.buffer && db)
+          return db.decode(a.subarray(b, c));
+        for (d = "";b < c; ) {
+          var e = a[b++];
+          if (e & 128) {
+            var h = a[b++] & 63;
+            if ((e & 224) == 192)
+              d += String.fromCharCode((e & 31) << 6 | h);
+            else {
+              var k = a[b++] & 63;
+              e = (e & 240) == 224 ? (e & 15) << 12 | h << 6 | k : (e & 7) << 18 | h << 12 | k << 6 | a[b++] & 63;
+              65536 > e ? d += String.fromCharCode(e) : (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023));
+            }
+          } else
+            d += String.fromCharCode(e);
+        }
+        return d;
+      }, ua = (a, b) => a ? B(x, a, b) : "", eb = (a, b) => {
+        for (var c = 0, d = a.length - 1;0 <= d; d--) {
+          var e = a[d];
+          e === "." ? a.splice(d, 1) : e === ".." ? (a.splice(d, 1), c++) : c && (a.splice(d, 1), c--);
+        }
+        if (b)
+          for (;c; c--)
+            a.unshift("..");
+        return a;
+      }, ka = (a) => {
+        var b = a.charAt(0) === "/", c = a.slice(-1) === "/";
+        (a = eb(a.split("/").filter((d) => !!d), !b).join("/")) || b || (a = ".");
+        a && c && (a += "/");
+        return (b ? "/" : "") + a;
+      }, fb = (a) => {
+        var b = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(a).slice(1);
+        a = b[0];
+        b = b[1];
+        if (!a && !b)
+          return ".";
+        b &&= b.slice(0, -1);
+        return a + b;
+      }, gb = (a) => a && a.match(/([^\/]+|\/)\/*$/)[1], hb = () => {
+        if (ca) {
+          var a = __require("crypto");
+          return (b) => a.randomFillSync(b);
+        }
+        return (b) => crypto.getRandomValues(b);
+      }, ib = (a) => {
+        (ib = hb())(a);
+      }, jb = (...a) => {
+        for (var b = "", c = false, d = a.length - 1;-1 <= d && !c; d--) {
+          c = 0 <= d ? a[d] : "/";
+          if (typeof c != "string")
+            throw new TypeError("Arguments to path.resolve must be strings");
+          if (!c)
+            return "";
+          b = c + "/" + b;
+          c = c.charAt(0) === "/";
+        }
+        b = eb(b.split("/").filter((e) => !!e), !c).join("/");
+        return (c ? "/" : "") + b || ".";
+      }, kb = [], ha = (a) => {
+        for (var b = 0, c = 0;c < a.length; ++c) {
+          var d = a.charCodeAt(c);
+          127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3;
+        }
+        return b;
+      }, u = (a, b, c, d) => {
+        if (!(0 < d))
+          return 0;
+        var e = c;
+        d = c + d - 1;
+        for (var h = 0;h < a.length; ++h) {
+          var k = a.charCodeAt(h);
+          if (55296 <= k && 57343 >= k) {
+            var q = a.charCodeAt(++h);
+            k = 65536 + ((k & 1023) << 10) | q & 1023;
+          }
+          if (127 >= k) {
+            if (c >= d)
+              break;
+            b[c++] = k;
+          } else {
+            if (2047 >= k) {
+              if (c + 1 >= d)
+                break;
+              b[c++] = 192 | k >> 6;
+            } else {
+              if (65535 >= k) {
+                if (c + 2 >= d)
+                  break;
+                b[c++] = 224 | k >> 12;
+              } else {
+                if (c + 3 >= d)
+                  break;
+                b[c++] = 240 | k >> 18;
+                b[c++] = 128 | k >> 12 & 63;
+              }
+              b[c++] = 128 | k >> 6 & 63;
+            }
+            b[c++] = 128 | k & 63;
+          }
+        }
+        b[c] = 0;
+        return c - e;
+      }, ra = (a, b) => {
+        var c = Array(ha(a) + 1);
+        a = u(a, c, 0, c.length);
+        b && (c.length = a);
+        return c;
+      }, mb = [];
+      function nb(a, b) {
+        mb[a] = { input: [], output: [], cb: b };
+        wb(a, xb);
+      }
+      var xb = { open(a) {
+        var b = mb[a.node.rdev];
+        if (!b)
+          throw new N(43);
+        a.tty = b;
+        a.seekable = false;
+      }, close(a) {
+        a.tty.cb.fsync(a.tty);
+      }, fsync(a) {
+        a.tty.cb.fsync(a.tty);
+      }, read(a, b, c, d) {
+        if (!a.tty || !a.tty.cb.xb)
+          throw new N(60);
+        for (var e = 0, h = 0;h < d; h++) {
+          try {
+            var k = a.tty.cb.xb(a.tty);
+          } catch (q) {
+            throw new N(29);
+          }
+          if (k === undefined && e === 0)
+            throw new N(6);
+          if (k === null || k === undefined)
+            break;
+          e++;
+          b[c + h] = k;
+        }
+        e && (a.node.atime = Date.now());
+        return e;
+      }, write(a, b, c, d) {
+        if (!a.tty || !a.tty.cb.qb)
+          throw new N(60);
+        try {
+          for (var e = 0;e < d; e++)
+            a.tty.cb.qb(a.tty, b[c + e]);
+        } catch (h) {
+          throw new N(29);
+        }
+        d && (a.node.mtime = a.node.ctime = Date.now());
+        return e;
+      } }, yb = { xb() {
+        a: {
+          if (!kb.length) {
+            var a = null;
+            if (ca) {
+              var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
+              try {
+                c = fs.readSync(d, b, 0, 256);
+              } catch (e) {
+                if (e.toString().includes("EOF"))
+                  c = 0;
+                else
+                  throw e;
+              }
+              0 < c && (a = b.slice(0, c).toString("utf-8"));
+            } else
+              typeof window != "undefined" && typeof window.prompt == "function" && (a = window.prompt("Input: "), a !== null && (a += `
+`));
+            if (!a) {
+              a = null;
+              break a;
+            }
+            kb = ra(a, true);
+          }
+          a = kb.shift();
+        }
+        return a;
+      }, qb(a, b) {
+        b === null || b === 10 ? (Ha(B(a.output)), a.output = []) : b != 0 && a.output.push(b);
+      }, fsync(a) {
+        0 < a.output?.length && (Ha(B(a.output)), a.output = []);
+      }, Tb() {
+        return { Ob: 25856, Qb: 5, Nb: 191, Pb: 35387, Mb: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
+      }, Ub() {
+        return 0;
+      }, Vb() {
+        return [24, 80];
+      } }, zb = { qb(a, b) {
+        b === null || b === 10 ? (Ia(B(a.output)), a.output = []) : b != 0 && a.output.push(b);
+      }, fsync(a) {
+        0 < a.output?.length && (Ia(B(a.output)), a.output = []);
+      } }, O = { Wa: null, Xa() {
+        return O.createNode(null, "/", 16895, 0);
+      }, createNode(a, b, c, d) {
+        if ((c & 61440) === 24576 || (c & 61440) === 4096)
+          throw new N(63);
+        O.Wa || (O.Wa = { dir: { node: { Ta: O.La.Ta, Ua: O.La.Ua, lookup: O.La.lookup, hb: O.La.hb, rename: O.La.rename, unlink: O.La.unlink, rmdir: O.La.rmdir, readdir: O.La.readdir, symlink: O.La.symlink }, stream: { Va: O.Ma.Va } }, file: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: { Va: O.Ma.Va, read: O.Ma.read, write: O.Ma.write, ib: O.Ma.ib, jb: O.Ma.jb } }, link: { node: { Ta: O.La.Ta, Ua: O.La.Ua, readlink: O.La.readlink }, stream: {} }, ub: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: Ab } });
+        c = Bb(a, b, c, d);
+        P(c.mode) ? (c.La = O.Wa.dir.node, c.Ma = O.Wa.dir.stream, c.Na = {}) : (c.mode & 61440) === 32768 ? (c.La = O.Wa.file.node, c.Ma = O.Wa.file.stream, c.Ra = 0, c.Na = null) : (c.mode & 61440) === 40960 ? (c.La = O.Wa.link.node, c.Ma = O.Wa.link.stream) : (c.mode & 61440) === 8192 && (c.La = O.Wa.ub.node, c.Ma = O.Wa.ub.stream);
+        c.atime = c.mtime = c.ctime = Date.now();
+        a && (a.Na[b] = c, a.atime = a.mtime = a.ctime = c.atime);
+        return c;
+      }, Sb(a) {
+        return a.Na ? a.Na.subarray ? a.Na.subarray(0, a.Ra) : new Uint8Array(a.Na) : new Uint8Array(0);
+      }, La: { Ta(a) {
+        var b = {};
+        b.dev = (a.mode & 61440) === 8192 ? a.id : 1;
+        b.ino = a.id;
+        b.mode = a.mode;
+        b.nlink = 1;
+        b.uid = 0;
+        b.gid = 0;
+        b.rdev = a.rdev;
+        P(a.mode) ? b.size = 4096 : (a.mode & 61440) === 32768 ? b.size = a.Ra : (a.mode & 61440) === 40960 ? b.size = a.link.length : b.size = 0;
+        b.atime = new Date(a.atime);
+        b.mtime = new Date(a.mtime);
+        b.ctime = new Date(a.ctime);
+        b.blksize = 4096;
+        b.blocks = Math.ceil(b.size / b.blksize);
+        return b;
+      }, Ua(a, b) {
+        for (var c of ["mode", "atime", "mtime", "ctime"])
+          b[c] != null && (a[c] = b[c]);
+        b.size !== undefined && (b = b.size, a.Ra != b && (b == 0 ? (a.Na = null, a.Ra = 0) : (c = a.Na, a.Na = new Uint8Array(b), c && a.Na.set(c.subarray(0, Math.min(b, a.Ra))), a.Ra = b)));
+      }, lookup() {
+        throw O.vb;
+      }, hb(a, b, c, d) {
+        return O.createNode(a, b, c, d);
+      }, rename(a, b, c) {
+        try {
+          var d = Q(b, c);
+        } catch (h) {}
+        if (d) {
+          if (P(a.mode))
+            for (var e in d.Na)
+              throw new N(55);
+          Cb(d);
+        }
+        delete a.parent.Na[a.name];
+        b.Na[c] = a;
+        a.name = c;
+        b.ctime = b.mtime = a.parent.ctime = a.parent.mtime = Date.now();
+      }, unlink(a, b) {
+        delete a.Na[b];
+        a.ctime = a.mtime = Date.now();
+      }, rmdir(a, b) {
+        var c = Q(a, b), d;
+        for (d in c.Na)
+          throw new N(55);
+        delete a.Na[b];
+        a.ctime = a.mtime = Date.now();
+      }, readdir(a) {
+        return [".", "..", ...Object.keys(a.Na)];
+      }, symlink(a, b, c) {
+        a = O.createNode(a, b, 41471, 0);
+        a.link = c;
+        return a;
+      }, readlink(a) {
+        if ((a.mode & 61440) !== 40960)
+          throw new N(28);
+        return a.link;
+      } }, Ma: { read(a, b, c, d, e) {
+        var h = a.node.Na;
+        if (e >= a.node.Ra)
+          return 0;
+        a = Math.min(a.node.Ra - e, d);
+        if (8 < a && h.subarray)
+          b.set(h.subarray(e, e + a), c);
+        else
+          for (d = 0;d < a; d++)
+            b[c + d] = h[e + d];
+        return a;
+      }, write(a, b, c, d, e, h) {
+        b.buffer === p.buffer && (h = false);
+        if (!d)
+          return 0;
+        a = a.node;
+        a.mtime = a.ctime = Date.now();
+        if (b.subarray && (!a.Na || a.Na.subarray)) {
+          if (h)
+            return a.Na = b.subarray(c, c + d), a.Ra = d;
+          if (a.Ra === 0 && e === 0)
+            return a.Na = b.slice(c, c + d), a.Ra = d;
+          if (e + d <= a.Ra)
+            return a.Na.set(b.subarray(c, c + d), e), d;
+        }
+        h = e + d;
+        var k = a.Na ? a.Na.length : 0;
+        k >= h || (h = Math.max(h, k * (1048576 > k ? 2 : 1.125) >>> 0), k != 0 && (h = Math.max(h, 256)), k = a.Na, a.Na = new Uint8Array(h), 0 < a.Ra && a.Na.set(k.subarray(0, a.Ra), 0));
+        if (a.Na.subarray && b.subarray)
+          a.Na.set(b.subarray(c, c + d), e);
+        else
+          for (h = 0;h < d; h++)
+            a.Na[e + h] = b[c + h];
+        a.Ra = Math.max(a.Ra, e + d);
+        return d;
+      }, Va(a, b, c) {
+        c === 1 ? b += a.position : c === 2 && (a.node.mode & 61440) === 32768 && (b += a.node.Ra);
+        if (0 > b)
+          throw new N(28);
+        return b;
+      }, ib(a, b, c, d, e) {
+        if ((a.node.mode & 61440) !== 32768)
+          throw new N(43);
+        a = a.node.Na;
+        if (e & 2 || !a || a.buffer !== p.buffer) {
+          e = true;
+          d = 65536 * Math.ceil(b / 65536);
+          var h = Db(65536, d);
+          h && x.fill(0, h, h + d);
+          d = h;
+          if (!d)
+            throw new N(48);
+          if (a) {
+            if (0 < c || c + b < a.length)
+              a.subarray ? a = a.subarray(c, c + b) : a = Array.prototype.slice.call(a, c, c + b);
+            p.set(a, d);
+          }
+        } else
+          e = false, d = a.byteOffset;
+        return { Kb: d, Ab: e };
+      }, jb(a, b, c, d) {
+        O.Ma.write(a, b, 0, d, c, false);
+        return 0;
+      } } }, la = (a, b) => {
+        var c = 0;
+        a && (c |= 365);
+        b && (c |= 146);
+        return c;
+      }, Eb = null, Fb = {}, Gb = [], Hb = 1, R = null, Ib = false, Jb = true, Kb = {}, N = class {
+        name = "ErrnoError";
+        constructor(a) {
+          this.Pa = a;
+        }
+      }, Lb = class {
+        gb = {};
+        node = null;
+        get flags() {
+          return this.gb.flags;
+        }
+        set flags(a) {
+          this.gb.flags = a;
+        }
+        get position() {
+          return this.gb.position;
+        }
+        set position(a) {
+          this.gb.position = a;
+        }
+      }, Mb = class {
+        La = {};
+        Ma = {};
+        ab = null;
+        constructor(a, b, c, d) {
+          a ||= this;
+          this.parent = a;
+          this.Xa = a.Xa;
+          this.id = Hb++;
+          this.name = b;
+          this.mode = c;
+          this.rdev = d;
+          this.atime = this.mtime = this.ctime = Date.now();
+        }
+        get read() {
+          return (this.mode & 365) === 365;
+        }
+        set read(a) {
+          a ? this.mode |= 365 : this.mode &= -366;
+        }
+        get write() {
+          return (this.mode & 146) === 146;
+        }
+        set write(a) {
+          a ? this.mode |= 146 : this.mode &= -147;
+        }
+      };
+      function S(a, b = {}) {
+        if (!a)
+          throw new N(44);
+        b.nb ?? (b.nb = true);
+        a.charAt(0) === "/" || (a = "//" + a);
+        var c = 0;
+        a:
+          for (;40 > c; c++) {
+            a = a.split("/").filter((q) => !!q);
+            for (var d = Eb, e = "/", h = 0;h < a.length; h++) {
+              var k = h === a.length - 1;
+              if (k && b.parent)
+                break;
+              if (a[h] !== ".")
+                if (a[h] === "..")
+                  e = fb(e), d = d.parent;
+                else {
+                  e = ka(e + "/" + a[h]);
+                  try {
+                    d = Q(d, a[h]);
+                  } catch (q) {
+                    if (q?.Pa === 44 && k && b.Jb)
+                      return { path: e };
+                    throw q;
+                  }
+                  !d.ab || k && !b.nb || (d = d.ab.root);
+                  if ((d.mode & 61440) === 40960 && (!k || b.$a)) {
+                    if (!d.La.readlink)
+                      throw new N(52);
+                    d = d.La.readlink(d);
+                    d.charAt(0) === "/" || (d = fb(e) + "/" + d);
+                    a = d + "/" + a.slice(h + 1).join("/");
+                    continue a;
+                  }
+                }
+            }
+            return { path: e, node: d };
+          }
+        throw new N(32);
+      }
+      function ja(a) {
+        for (var b;; ) {
+          if (a === a.parent)
+            return a = a.Xa.zb, b ? a[a.length - 1] !== "/" ? `${a}/${b}` : a + b : a;
+          b = b ? `${a.name}/${b}` : a.name;
+          a = a.parent;
+        }
+      }
+      function Nb(a, b) {
+        for (var c = 0, d = 0;d < b.length; d++)
+          c = (c << 5) - c + b.charCodeAt(d) | 0;
+        return (a + c >>> 0) % R.length;
+      }
+      function Cb(a) {
+        var b = Nb(a.parent.id, a.name);
+        if (R[b] === a)
+          R[b] = a.bb;
+        else
+          for (b = R[b];b; ) {
+            if (b.bb === a) {
+              b.bb = a.bb;
+              break;
+            }
+            b = b.bb;
+          }
+      }
+      function Q(a, b) {
+        var c = P(a.mode) ? (c = Ob(a, "x")) ? c : a.La.lookup ? 0 : 2 : 54;
+        if (c)
+          throw new N(c);
+        for (c = R[Nb(a.id, b)];c; c = c.bb) {
+          var d = c.name;
+          if (c.parent.id === a.id && d === b)
+            return c;
+        }
+        return a.La.lookup(a, b);
+      }
+      function Bb(a, b, c, d) {
+        a = new Mb(a, b, c, d);
+        b = Nb(a.parent.id, a.name);
+        a.bb = R[b];
+        return R[b] = a;
+      }
+      function P(a) {
+        return (a & 61440) === 16384;
+      }
+      function Pb(a) {
+        var b = ["r", "w", "rw"][a & 3];
+        a & 512 && (b += "w");
+        return b;
+      }
+      function Ob(a, b) {
+        if (Jb)
+          return 0;
+        if (!b.includes("r") || a.mode & 292) {
+          if (b.includes("w") && !(a.mode & 146) || b.includes("x") && !(a.mode & 73))
+            return 2;
+        } else
+          return 2;
+        return 0;
+      }
+      function Qb(a, b) {
+        if (!P(a.mode))
+          return 54;
+        try {
+          return Q(a, b), 20;
+        } catch (c) {}
+        return Ob(a, "wx");
+      }
+      function Rb(a, b, c) {
+        try {
+          var d = Q(a, b);
+        } catch (e) {
+          return e.Pa;
+        }
+        if (a = Ob(a, "wx"))
+          return a;
+        if (c) {
+          if (!P(d.mode))
+            return 54;
+          if (d === d.parent || ja(d) === "/")
+            return 10;
+        } else if (P(d.mode))
+          return 31;
+        return 0;
+      }
+      function Sb(a) {
+        if (!a)
+          throw new N(63);
+        return a;
+      }
+      function T(a) {
+        a = Gb[a];
+        if (!a)
+          throw new N(8);
+        return a;
+      }
+      function Tb(a, b = -1) {
+        a = Object.assign(new Lb, a);
+        if (b == -1)
+          a: {
+            for (b = 0;4096 >= b; b++)
+              if (!Gb[b])
+                break a;
+            throw new N(33);
+          }
+        a.fd = b;
+        return Gb[b] = a;
+      }
+      function Ub(a, b = -1) {
+        a = Tb(a, b);
+        a.Ma?.Rb?.(a);
+        return a;
+      }
+      function Vb(a, b, c) {
+        var d = a?.Ma.Ua;
+        a = d ? a : b;
+        d ??= b.La.Ua;
+        Sb(d);
+        d(a, c);
+      }
+      var Ab = { open(a) {
+        a.Ma = Fb[a.node.rdev].Ma;
+        a.Ma.open?.(a);
+      }, Va() {
+        throw new N(70);
+      } };
+      function wb(a, b) {
+        Fb[a] = { Ma: b };
+      }
+      function Wb(a, b) {
+        var c = b === "/";
+        if (c && Eb)
+          throw new N(10);
+        if (!c && b) {
+          var d = S(b, { nb: false });
+          b = d.path;
+          d = d.node;
+          if (d.ab)
+            throw new N(10);
+          if (!P(d.mode))
+            throw new N(54);
+        }
+        b = { type: a, Wb: {}, zb: b, Ib: [] };
+        a = a.Xa(b);
+        a.Xa = b;
+        b.root = a;
+        c ? Eb = a : d && (d.ab = b, d.Xa && d.Xa.Ib.push(b));
+      }
+      function Xb(a, b, c) {
+        var d = S(a, { parent: true }).node;
+        a = gb(a);
+        if (!a)
+          throw new N(28);
+        if (a === "." || a === "..")
+          throw new N(20);
+        var e = Qb(d, a);
+        if (e)
+          throw new N(e);
+        if (!d.La.hb)
+          throw new N(63);
+        return d.La.hb(d, a, b, c);
+      }
+      function ma(a, b = 438) {
+        return Xb(a, b & 4095 | 32768, 0);
+      }
+      function U(a, b = 511) {
+        return Xb(a, b & 1023 | 16384, 0);
+      }
+      function Yb(a, b, c) {
+        typeof c == "undefined" && (c = b, b = 438);
+        Xb(a, b | 8192, c);
+      }
+      function Zb(a, b) {
+        if (!jb(a))
+          throw new N(44);
+        var c = S(b, { parent: true }).node;
+        if (!c)
+          throw new N(44);
+        b = gb(b);
+        var d = Qb(c, b);
+        if (d)
+          throw new N(d);
+        if (!c.La.symlink)
+          throw new N(63);
+        c.La.symlink(c, b, a);
+      }
+      function $b(a) {
+        var b = S(a, { parent: true }).node;
+        a = gb(a);
+        var c = Q(b, a), d = Rb(b, a, true);
+        if (d)
+          throw new N(d);
+        if (!b.La.rmdir)
+          throw new N(63);
+        if (c.ab)
+          throw new N(10);
+        b.La.rmdir(b, a);
+        Cb(c);
+      }
+      function za(a) {
+        var b = S(a, { parent: true }).node;
+        if (!b)
+          throw new N(44);
+        a = gb(a);
+        var c = Q(b, a), d = Rb(b, a, false);
+        if (d)
+          throw new N(d);
+        if (!b.La.unlink)
+          throw new N(63);
+        if (c.ab)
+          throw new N(10);
+        b.La.unlink(b, a);
+        Cb(c);
+      }
+      function ac(a, b) {
+        a = S(a, { $a: !b }).node;
+        return Sb(a.La.Ta)(a);
+      }
+      function bc(a, b, c, d) {
+        Vb(a, b, { mode: c & 4095 | b.mode & -4096, ctime: Date.now(), Fb: d });
+      }
+      function na(a, b) {
+        a = typeof a == "string" ? S(a, { $a: true }).node : a;
+        bc(null, a, b);
+      }
+      function cc(a, b, c) {
+        if (P(b.mode))
+          throw new N(31);
+        if ((b.mode & 61440) !== 32768)
+          throw new N(28);
+        var d = Ob(b, "w");
+        if (d)
+          throw new N(d);
+        Vb(a, b, { size: c, timestamp: Date.now() });
+      }
+      function oa(a, b, c = 438) {
+        if (a === "")
+          throw new N(44);
+        if (typeof b == "string") {
+          var d = { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }[b];
+          if (typeof d == "undefined")
+            throw Error(`Unknown file open mode: ${b}`);
+          b = d;
+        }
+        c = b & 64 ? c & 4095 | 32768 : 0;
+        if (typeof a == "object")
+          d = a;
+        else {
+          var e = a.endsWith("/");
+          a = S(a, { $a: !(b & 131072), Jb: true });
+          d = a.node;
+          a = a.path;
+        }
+        var h = false;
+        if (b & 64)
+          if (d) {
+            if (b & 128)
+              throw new N(20);
+          } else {
+            if (e)
+              throw new N(31);
+            d = Xb(a, c | 511, 0);
+            h = true;
+          }
+        if (!d)
+          throw new N(44);
+        (d.mode & 61440) === 8192 && (b &= -513);
+        if (b & 65536 && !P(d.mode))
+          throw new N(54);
+        if (!h && (e = d ? (d.mode & 61440) === 40960 ? 32 : P(d.mode) && (Pb(b) !== "r" || b & 576) ? 31 : Ob(d, Pb(b)) : 44))
+          throw new N(e);
+        b & 512 && !h && (e = d, e = typeof e == "string" ? S(e, { $a: true }).node : e, cc(null, e, 0));
+        b &= -131713;
+        e = Tb({ node: d, path: ja(d), flags: b, seekable: true, position: 0, Ma: d.Ma, Lb: [], error: false });
+        e.Ma.open && e.Ma.open(e);
+        h && na(d, c & 511);
+        !f.logReadFiles || b & 1 || a in Kb || (Kb[a] = 1);
+        return e;
+      }
+      function qa(a) {
+        if (a.fd === null)
+          throw new N(8);
+        a.ob && (a.ob = null);
+        try {
+          a.Ma.close && a.Ma.close(a);
+        } catch (b) {
+          throw b;
+        } finally {
+          Gb[a.fd] = null;
+        }
+        a.fd = null;
+      }
+      function mc(a, b, c) {
+        if (a.fd === null)
+          throw new N(8);
+        if (!a.seekable || !a.Ma.Va)
+          throw new N(70);
+        if (c != 0 && c != 1 && c != 2)
+          throw new N(28);
+        a.position = a.Ma.Va(a, b, c);
+        a.Lb = [];
+      }
+      function Ec(a, b, c, d, e) {
+        if (0 > d || 0 > e)
+          throw new N(28);
+        if (a.fd === null)
+          throw new N(8);
+        if ((a.flags & 2097155) === 1)
+          throw new N(8);
+        if (P(a.node.mode))
+          throw new N(31);
+        if (!a.Ma.read)
+          throw new N(28);
+        var h = typeof e != "undefined";
+        if (!h)
+          e = a.position;
+        else if (!a.seekable)
+          throw new N(70);
+        b = a.Ma.read(a, b, c, d, e);
+        h || (a.position += b);
+        return b;
+      }
+      function pa(a, b, c, d, e) {
+        if (0 > d || 0 > e)
+          throw new N(28);
+        if (a.fd === null)
+          throw new N(8);
+        if ((a.flags & 2097155) === 0)
+          throw new N(8);
+        if (P(a.node.mode))
+          throw new N(31);
+        if (!a.Ma.write)
+          throw new N(28);
+        a.seekable && a.flags & 1024 && mc(a, 0, 2);
+        var h = typeof e != "undefined";
+        if (!h)
+          e = a.position;
+        else if (!a.seekable)
+          throw new N(70);
+        b = a.Ma.write(a, b, c, d, e, undefined);
+        h || (a.position += b);
+        return b;
+      }
+      function ya(a) {
+        var b = "binary";
+        if (b !== "utf8" && b !== "binary")
+          throw Error(`Invalid encoding type "${b}"`);
+        var c;
+        var d = oa(a, d || 0);
+        a = ac(a).size;
+        var e = new Uint8Array(a);
+        Ec(d, e, 0, a, 0);
+        b === "utf8" ? c = B(e) : b === "binary" && (c = e);
+        qa(d);
+        return c;
+      }
+      function V(a, b, c) {
+        a = ka("/dev/" + a);
+        var d = la(!!b, !!c);
+        V.yb ?? (V.yb = 64);
+        var e = V.yb++ << 8 | 0;
+        wb(e, { open(h) {
+          h.seekable = false;
+        }, close() {
+          c?.buffer?.length && c(10);
+        }, read(h, k, q, w) {
+          for (var v = 0, C = 0;C < w; C++) {
+            try {
+              var G = b();
+            } catch (pb) {
+              throw new N(29);
+            }
+            if (G === undefined && v === 0)
+              throw new N(6);
+            if (G === null || G === undefined)
+              break;
+            v++;
+            k[q + C] = G;
+          }
+          v && (h.node.atime = Date.now());
+          return v;
+        }, write(h, k, q, w) {
+          for (var v = 0;v < w; v++)
+            try {
+              c(k[q + v]);
+            } catch (C) {
+              throw new N(29);
+            }
+          w && (h.node.mtime = h.node.ctime = Date.now());
+          return v;
+        } });
+        Yb(a, d, e);
+      }
+      var W = {};
+      function Gc(a, b, c) {
+        if (b.charAt(0) === "/")
+          return b;
+        a = a === -100 ? "/" : T(a).path;
+        if (b.length == 0) {
+          if (!c)
+            throw new N(44);
+          return a;
+        }
+        return a + "/" + b;
+      }
+      function Hc(a, b) {
+        E[a >> 2] = b.dev;
+        E[a + 4 >> 2] = b.mode;
+        F[a + 8 >> 2] = b.nlink;
+        E[a + 12 >> 2] = b.uid;
+        E[a + 16 >> 2] = b.gid;
+        E[a + 20 >> 2] = b.rdev;
+        H[a + 24 >> 3] = BigInt(b.size);
+        E[a + 32 >> 2] = 4096;
+        E[a + 36 >> 2] = b.blocks;
+        var c = b.atime.getTime(), d = b.mtime.getTime(), e = b.ctime.getTime();
+        H[a + 40 >> 3] = BigInt(Math.floor(c / 1000));
+        F[a + 48 >> 2] = c % 1000 * 1e6;
+        H[a + 56 >> 3] = BigInt(Math.floor(d / 1000));
+        F[a + 64 >> 2] = d % 1000 * 1e6;
+        H[a + 72 >> 3] = BigInt(Math.floor(e / 1000));
+        F[a + 80 >> 2] = e % 1000 * 1e6;
+        H[a + 88 >> 3] = BigInt(b.ino);
+        return 0;
+      }
+      var Ic = undefined, Jc = () => {
+        var a = E[+Ic >> 2];
+        Ic += 4;
+        return a;
+      }, Kc = 0, Lc = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Mc = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Nc = {}, Oc = (a) => {
+        Ma = a;
+        cb || 0 < Kc || (f.onExit?.(a), La = true);
+        Da(a, new Ya(a));
+      }, Pc = (a) => {
+        if (!La)
+          try {
+            if (a(), !(cb || 0 < Kc))
+              try {
+                Ma = a = Ma, Oc(a);
+              } catch (b) {
+                b instanceof Ya || b == "unwind" || Da(1, b);
+              }
+          } catch (b) {
+            b instanceof Ya || b == "unwind" || Da(1, b);
+          }
+      }, Qc = {}, Sc = () => {
+        if (!Rc) {
+          var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: Ca || "./this.program" }, b;
+          for (b in Qc)
+            Qc[b] === undefined ? delete a[b] : a[b] = Qc[b];
+          var c = [];
+          for (b in a)
+            c.push(`${b}=${a[b]}`);
+          Rc = c;
+        }
+        return Rc;
+      }, Rc, xa = (a) => {
+        var b = ha(a) + 1, c = z(b);
+        u(a, x, c, b);
+        return c;
+      }, Tc = (a, b, c, d) => {
+        var e = { string: (v) => {
+          var C = 0;
+          v !== null && v !== undefined && v !== 0 && (C = xa(v));
+          return C;
+        }, array: (v) => {
+          var C = z(v.length);
+          p.set(v, C);
+          return C;
+        } };
+        a = f["_" + a];
+        var h = [], k = 0;
+        if (d)
+          for (var q = 0;q < d.length; q++) {
+            var w = e[c[q]];
+            w ? (k === 0 && (k = sa()), h[q] = w(d[q])) : h[q] = d[q];
+          }
+        c = a(...h);
+        return c = function(v) {
+          k !== 0 && wa(k);
+          return b === "string" ? v ? B(x, v) : "" : b === "boolean" ? !!v : v;
+        }(c);
+      }, ea = 0, da = (a, b) => {
+        b = b == 1 ? z(a.length) : ia(a.length);
+        a.subarray || a.slice || (a = new Uint8Array(a));
+        x.set(a, b);
+        return b;
+      }, Uc, Vc = [], Y, A = (a) => {
+        Uc.delete(Y.get(a));
+        Y.set(a, null);
+        Vc.push(a);
+      }, Aa = (a, b) => {
+        if (!Uc) {
+          Uc = new WeakMap;
+          var c = Y.length;
+          if (Uc)
+            for (var d = 0;d < 0 + c; d++) {
+              var e = Y.get(d);
+              e && Uc.set(e, d);
+            }
+        }
+        if (c = Uc.get(a) || 0)
+          return c;
+        if (Vc.length)
+          c = Vc.pop();
+        else {
+          try {
+            Y.grow(1);
+          } catch (w) {
+            if (!(w instanceof RangeError))
+              throw w;
+            throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
+          }
+          c = Y.length - 1;
+        }
+        try {
+          Y.set(c, a);
+        } catch (w) {
+          if (!(w instanceof TypeError))
+            throw w;
+          if (typeof WebAssembly.Function == "function") {
+            var h = WebAssembly.Function;
+            d = { i: "i32", j: "i64", f: "f32", d: "f64", e: "externref", p: "i32" };
+            e = { parameters: [], results: b[0] == "v" ? [] : [d[b[0]]] };
+            for (var k = 1;k < b.length; ++k)
+              e.parameters.push(d[b[k]]);
+            b = new h(e, a);
+          } else {
+            d = [1];
+            e = b.slice(0, 1);
+            b = b.slice(1);
+            k = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+            d.push(96);
+            var q = b.length;
+            128 > q ? d.push(q) : d.push(q % 128 | 128, q >> 7);
+            for (h of b)
+              d.push(k[h]);
+            e == "v" ? d.push(0) : d.push(1, k[e]);
+            b = [0, 97, 115, 109, 1, 0, 0, 0, 1];
+            h = d.length;
+            128 > h ? b.push(h) : b.push(h % 128 | 128, h >> 7);
+            b.push(...d);
+            b.push(2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+            b = new WebAssembly.Module(new Uint8Array(b));
+            b = new WebAssembly.Instance(b, { e: { f: a } }).exports.f;
+          }
+          Y.set(c, b);
+        }
+        Uc.set(a, c);
+        return c;
+      };
+      R = Array(4096);
+      Wb(O, "/");
+      U("/tmp");
+      U("/home");
+      U("/home/web_user");
+      (function() {
+        U("/dev");
+        wb(259, { read: () => 0, write: (d, e, h, k) => k, Va: () => 0 });
+        Yb("/dev/null", 259);
+        nb(1280, yb);
+        nb(1536, zb);
+        Yb("/dev/tty", 1280);
+        Yb("/dev/tty1", 1536);
+        var a = new Uint8Array(1024), b = 0, c = () => {
+          b === 0 && (ib(a), b = a.byteLength);
+          return a[--b];
+        };
+        V("random", c);
+        V("urandom", c);
+        U("/dev/shm");
+        U("/dev/shm/tmp");
+      })();
+      (function() {
+        U("/proc");
+        var a = U("/proc/self");
+        U("/proc/self/fd");
+        Wb({ Xa() {
+          var b = Bb(a, "fd", 16895, 73);
+          b.Ma = { Va: O.Ma.Va };
+          b.La = { lookup(c, d) {
+            c = +d;
+            var e = T(c);
+            c = { parent: null, Xa: { zb: "fake" }, La: { readlink: () => e.path }, id: c + 1 };
+            return c.parent = c;
+          }, readdir() {
+            return Array.from(Gb.entries()).filter(([, c]) => c).map(([c]) => c.toString());
+          } };
+          return b;
+        } }, "/proc/self/fd");
+      })();
+      O.vb = new N(44);
+      O.vb.stack = "<generic error, no stack>";
+      var Xc = { a: (a, b, c, d) => Ta(`Assertion failed: ${a ? B(x, a) : ""}, at: ` + [b ? b ? B(x, b) : "" : "unknown filename", c, d ? d ? B(x, d) : "" : "unknown function"]), i: function(a, b) {
+        try {
+          return a = a ? B(x, a) : "", na(a, b), 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, L: function(a, b, c) {
+        try {
+          b = b ? B(x, b) : "";
+          b = Gc(a, b);
+          if (c & -8)
+            return -28;
+          var d = S(b, { $a: true }).node;
+          if (!d)
+            return -44;
+          a = "";
+          c & 4 && (a += "r");
+          c & 2 && (a += "w");
+          c & 1 && (a += "x");
+          return a && Ob(d, a) ? -2 : 0;
+        } catch (e) {
+          if (typeof W == "undefined" || e.name !== "ErrnoError")
+            throw e;
+          return -e.Pa;
+        }
+      }, j: function(a, b) {
+        try {
+          var c = T(a);
+          bc(c, c.node, b, false);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, h: function(a) {
+        try {
+          var b = T(a);
+          Vb(b, b.node, { timestamp: Date.now(), Fb: false });
+          return 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, b: function(a, b, c) {
+        Ic = c;
+        try {
+          var d = T(a);
+          switch (b) {
+            case 0:
+              var e = Jc();
+              if (0 > e)
+                break;
+              for (;Gb[e]; )
+                e++;
+              return Ub(d, e).fd;
+            case 1:
+            case 2:
+              return 0;
+            case 3:
+              return d.flags;
+            case 4:
+              return e = Jc(), d.flags |= e, 0;
+            case 12:
+              return e = Jc(), Na[e + 0 >> 1] = 2, 0;
+            case 13:
+            case 14:
+              return 0;
+          }
+          return -28;
+        } catch (h) {
+          if (typeof W == "undefined" || h.name !== "ErrnoError")
+            throw h;
+          return -h.Pa;
+        }
+      }, g: function(a, b) {
+        try {
+          var c = T(a), d = c.node, e = c.Ma.Ta;
+          a = e ? c : d;
+          e ??= d.La.Ta;
+          Sb(e);
+          var h = e(a);
+          return Hc(b, h);
+        } catch (k) {
+          if (typeof W == "undefined" || k.name !== "ErrnoError")
+            throw k;
+          return -k.Pa;
+        }
+      }, H: function(a, b) {
+        b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+        try {
+          if (isNaN(b))
+            return 61;
+          var c = T(a);
+          if (0 > b || (c.flags & 2097155) === 0)
+            throw new N(28);
+          cc(c, c.node, b);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, G: function(a, b) {
+        try {
+          if (b === 0)
+            return -28;
+          var c = ha("/") + 1;
+          if (b < c)
+            return -68;
+          u("/", x, a, b);
+          return c;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, K: function(a, b) {
+        try {
+          return a = a ? B(x, a) : "", Hc(b, ac(a, true));
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, C: function(a, b, c) {
+        try {
+          return b = b ? B(x, b) : "", b = Gc(a, b), U(b, c), 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, J: function(a, b, c, d) {
+        try {
+          b = b ? B(x, b) : "";
+          var e = d & 256;
+          b = Gc(a, b, d & 4096);
+          return Hc(c, e ? ac(b, true) : ac(b));
+        } catch (h) {
+          if (typeof W == "undefined" || h.name !== "ErrnoError")
+            throw h;
+          return -h.Pa;
+        }
+      }, x: function(a, b, c, d) {
+        Ic = d;
+        try {
+          b = b ? B(x, b) : "";
+          b = Gc(a, b);
+          var e = d ? Jc() : 0;
+          return oa(b, c, e).fd;
+        } catch (h) {
+          if (typeof W == "undefined" || h.name !== "ErrnoError")
+            throw h;
+          return -h.Pa;
+        }
+      }, v: function(a, b, c, d) {
+        try {
+          b = b ? B(x, b) : "";
+          b = Gc(a, b);
+          if (0 >= d)
+            return -28;
+          var e = S(b).node;
+          if (!e)
+            throw new N(44);
+          if (!e.La.readlink)
+            throw new N(28);
+          var h = e.La.readlink(e);
+          var k = Math.min(d, ha(h)), q = p[c + k];
+          u(h, x, c, d + 1);
+          p[c + k] = q;
+          return k;
+        } catch (w) {
+          if (typeof W == "undefined" || w.name !== "ErrnoError")
+            throw w;
+          return -w.Pa;
+        }
+      }, u: function(a) {
+        try {
+          return a = a ? B(x, a) : "", $b(a), 0;
+        } catch (b) {
+          if (typeof W == "undefined" || b.name !== "ErrnoError")
+            throw b;
+          return -b.Pa;
+        }
+      }, f: function(a, b) {
+        try {
+          return a = a ? B(x, a) : "", Hc(b, ac(a));
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, r: function(a, b, c) {
+        try {
+          return b = b ? B(x, b) : "", b = Gc(a, b), c === 0 ? za(b) : c === 512 ? $b(b) : Ta("Invalid flags passed to unlinkat"), 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, q: function(a, b, c) {
+        try {
+          b = b ? B(x, b) : "";
+          b = Gc(a, b, true);
+          var d = Date.now(), e, h;
+          if (c) {
+            var k = F[c >> 2] + 4294967296 * E[c + 4 >> 2], q = E[c + 8 >> 2];
+            q == 1073741823 ? e = d : q == 1073741822 ? e = null : e = 1000 * k + q / 1e6;
+            c += 16;
+            k = F[c >> 2] + 4294967296 * E[c + 4 >> 2];
+            q = E[c + 8 >> 2];
+            q == 1073741823 ? h = d : q == 1073741822 ? h = null : h = 1000 * k + q / 1e6;
+          } else
+            h = e = d;
+          if ((h ?? e) !== null) {
+            a = e;
+            var w = S(b, { $a: true }).node;
+            Sb(w.La.Ua)(w, { atime: a, mtime: h });
+          }
+          return 0;
+        } catch (v) {
+          if (typeof W == "undefined" || v.name !== "ErrnoError")
+            throw v;
+          return -v.Pa;
+        }
+      }, m: () => Ta(""), l: () => {
+        cb = false;
+        Kc = 0;
+      }, A: function(a, b) {
+        a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);
+        a = new Date(1000 * a);
+        E[b >> 2] = a.getSeconds();
+        E[b + 4 >> 2] = a.getMinutes();
+        E[b + 8 >> 2] = a.getHours();
+        E[b + 12 >> 2] = a.getDate();
+        E[b + 16 >> 2] = a.getMonth();
+        E[b + 20 >> 2] = a.getFullYear() - 1900;
+        E[b + 24 >> 2] = a.getDay();
+        var c = a.getFullYear();
+        E[b + 28 >> 2] = (c % 4 !== 0 || c % 100 === 0 && c % 400 !== 0 ? Mc : Lc)[a.getMonth()] + a.getDate() - 1 | 0;
+        E[b + 36 >> 2] = -(60 * a.getTimezoneOffset());
+        c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset();
+        var d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();
+        E[b + 32 >> 2] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0;
+      }, y: function(a, b, c, d, e, h, k) {
+        e = -9007199254740992 > e || 9007199254740992 < e ? NaN : Number(e);
+        try {
+          if (isNaN(e))
+            return 61;
+          var q = T(d);
+          if ((b & 2) !== 0 && (c & 2) === 0 && (q.flags & 2097155) !== 2)
+            throw new N(2);
+          if ((q.flags & 2097155) === 1)
+            throw new N(2);
+          if (!q.Ma.ib)
+            throw new N(43);
+          if (!a)
+            throw new N(28);
+          var w = q.Ma.ib(q, a, e, b, c);
+          var v = w.Kb;
+          E[h >> 2] = w.Ab;
+          F[k >> 2] = v;
+          return 0;
+        } catch (C) {
+          if (typeof W == "undefined" || C.name !== "ErrnoError")
+            throw C;
+          return -C.Pa;
+        }
+      }, z: function(a, b, c, d, e, h) {
+        h = -9007199254740992 > h || 9007199254740992 < h ? NaN : Number(h);
+        try {
+          var k = T(e);
+          if (c & 2) {
+            c = h;
+            if ((k.node.mode & 61440) !== 32768)
+              throw new N(43);
+            if (!(d & 2)) {
+              var q = x.slice(a, a + b);
+              k.Ma.jb && k.Ma.jb(k, q, c, b, d);
+            }
+          }
+        } catch (w) {
+          if (typeof W == "undefined" || w.name !== "ErrnoError")
+            throw w;
+          return -w.Pa;
+        }
+      }, n: (a, b) => {
+        Nc[a] && (clearTimeout(Nc[a].id), delete Nc[a]);
+        if (!b)
+          return 0;
+        var c = setTimeout(() => {
+          delete Nc[a];
+          Pc(() => Wc(a, performance.now()));
+        }, b);
+        Nc[a] = {
+          id: c,
+          Xb: b
+        };
+        return 0;
+      }, B: (a, b, c, d) => {
+        var e = new Date().getFullYear(), h = new Date(e, 0, 1).getTimezoneOffset();
+        e = new Date(e, 6, 1).getTimezoneOffset();
+        F[a >> 2] = 60 * Math.max(h, e);
+        E[b >> 2] = Number(h != e);
+        b = (k) => {
+          var q = Math.abs(k);
+          return `UTC${0 <= k ? "-" : "+"}${String(Math.floor(q / 60)).padStart(2, "0")}${String(q % 60).padStart(2, "0")}`;
+        };
+        a = b(h);
+        b = b(e);
+        e < h ? (u(a, x, c, 17), u(b, x, d, 17)) : (u(a, x, d, 17), u(b, x, c, 17));
+      }, d: () => Date.now(), s: () => 2147483648, c: () => performance.now(), o: (a) => {
+        var b = x.length;
+        a >>>= 0;
+        if (2147483648 < a)
+          return false;
+        for (var c = 1;4 >= c; c *= 2) {
+          var d = b * (1 + 0.2 / c);
+          d = Math.min(d, a + 100663296);
+          a: {
+            d = (Math.min(2147483648, 65536 * Math.ceil(Math.max(a, d) / 65536)) - Ka.buffer.byteLength + 65535) / 65536 | 0;
+            try {
+              Ka.grow(d);
+              Qa();
+              var e = 1;
+              break a;
+            } catch (h) {}
+            e = undefined;
+          }
+          if (e)
+            return true;
+        }
+        return false;
+      }, E: (a, b) => {
+        var c = 0;
+        Sc().forEach((d, e) => {
+          var h = b + c;
+          e = F[a + 4 * e >> 2] = h;
+          for (h = 0;h < d.length; ++h)
+            p[e++] = d.charCodeAt(h);
+          p[e] = 0;
+          c += d.length + 1;
+        });
+        return 0;
+      }, F: (a, b) => {
+        var c = Sc();
+        F[a >> 2] = c.length;
+        var d = 0;
+        c.forEach((e) => d += e.length + 1);
+        F[b >> 2] = d;
+        return 0;
+      }, e: function(a) {
+        try {
+          var b = T(a);
+          qa(b);
+          return 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return c.Pa;
+        }
+      }, p: function(a, b) {
+        try {
+          var c = T(a);
+          p[b] = c.tty ? 2 : P(c.mode) ? 3 : (c.mode & 61440) === 40960 ? 7 : 4;
+          Na[b + 2 >> 1] = 0;
+          H[b + 8 >> 3] = BigInt(0);
+          H[b + 16 >> 3] = BigInt(0);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return d.Pa;
+        }
+      }, w: function(a, b, c, d) {
+        try {
+          a: {
+            var e = T(a);
+            a = b;
+            for (var h, k = b = 0;k < c; k++) {
+              var q = F[a >> 2], w = F[a + 4 >> 2];
+              a += 8;
+              var v = Ec(e, p, q, w, h);
+              if (0 > v) {
+                var C = -1;
+                break a;
+              }
+              b += v;
+              if (v < w)
+                break;
+              typeof h != "undefined" && (h += v);
+            }
+            C = b;
+          }
+          F[d >> 2] = C;
+          return 0;
+        } catch (G) {
+          if (typeof W == "undefined" || G.name !== "ErrnoError")
+            throw G;
+          return G.Pa;
+        }
+      }, D: function(a, b, c, d) {
+        b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+        try {
+          if (isNaN(b))
+            return 61;
+          var e = T(a);
+          mc(e, b, c);
+          H[d >> 3] = BigInt(e.position);
+          e.ob && b === 0 && c === 0 && (e.ob = null);
+          return 0;
+        } catch (h) {
+          if (typeof W == "undefined" || h.name !== "ErrnoError")
+            throw h;
+          return h.Pa;
+        }
+      }, I: function(a) {
+        try {
+          var b = T(a);
+          return b.Ma?.fsync ? b.Ma.fsync(b) : 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return c.Pa;
+        }
+      }, t: function(a, b, c, d) {
+        try {
+          a: {
+            var e = T(a);
+            a = b;
+            for (var h, k = b = 0;k < c; k++) {
+              var q = F[a >> 2], w = F[a + 4 >> 2];
+              a += 8;
+              var v = pa(e, p, q, w, h);
+              if (0 > v) {
+                var C = -1;
+                break a;
+              }
+              b += v;
+              if (v < w)
+                break;
+              typeof h != "undefined" && (h += v);
+            }
+            C = b;
+          }
+          F[d >> 2] = C;
+          return 0;
+        } catch (G) {
+          if (typeof W == "undefined" || G.name !== "ErrnoError")
+            throw G;
+          return G.Pa;
+        }
+      }, k: Oc }, Z;
+      (async function() {
+        function a(c) {
+          Z = c.exports;
+          Ka = Z.M;
+          Qa();
+          Y = Z.O;
+          K--;
+          f.monitorRunDependencies?.(K);
+          K == 0 && Sa && (c = Sa, Sa = null, c());
+          return Z;
+        }
+        K++;
+        f.monitorRunDependencies?.(K);
+        var b = { a: Xc };
+        if (f.instantiateWasm)
+          return new Promise((c) => {
+            f.instantiateWasm(b, (d, e) => {
+              a(d, e);
+              c(d.exports);
+            });
+          });
+        Ua ??= f.locateFile ? f.locateFile("sql-wasm.wasm", D) : D + "sql-wasm.wasm";
+        return a((await Xa(b)).instance);
+      })();
+      f._sqlite3_free = (a) => (f._sqlite3_free = Z.P)(a);
+      f._sqlite3_value_text = (a) => (f._sqlite3_value_text = Z.Q)(a);
+      f._sqlite3_prepare_v2 = (a, b, c, d, e) => (f._sqlite3_prepare_v2 = Z.R)(a, b, c, d, e);
+      f._sqlite3_step = (a) => (f._sqlite3_step = Z.S)(a);
+      f._sqlite3_reset = (a) => (f._sqlite3_reset = Z.T)(a);
+      f._sqlite3_exec = (a, b, c, d, e) => (f._sqlite3_exec = Z.U)(a, b, c, d, e);
+      f._sqlite3_finalize = (a) => (f._sqlite3_finalize = Z.V)(a);
+      f._sqlite3_column_name = (a, b) => (f._sqlite3_column_name = Z.W)(a, b);
+      f._sqlite3_column_text = (a, b) => (f._sqlite3_column_text = Z.X)(a, b);
+      f._sqlite3_column_type = (a, b) => (f._sqlite3_column_type = Z.Y)(a, b);
+      f._sqlite3_errmsg = (a) => (f._sqlite3_errmsg = Z.Z)(a);
+      f._sqlite3_clear_bindings = (a) => (f._sqlite3_clear_bindings = Z._)(a);
+      f._sqlite3_value_blob = (a) => (f._sqlite3_value_blob = Z.$)(a);
+      f._sqlite3_value_bytes = (a) => (f._sqlite3_value_bytes = Z.aa)(a);
+      f._sqlite3_value_double = (a) => (f._sqlite3_value_double = Z.ba)(a);
+      f._sqlite3_value_int = (a) => (f._sqlite3_value_int = Z.ca)(a);
+      f._sqlite3_value_type = (a) => (f._sqlite3_value_type = Z.da)(a);
+      f._sqlite3_result_blob = (a, b, c, d) => (f._sqlite3_result_blob = Z.ea)(a, b, c, d);
+      f._sqlite3_result_double = (a, b) => (f._sqlite3_result_double = Z.fa)(a, b);
+      f._sqlite3_result_error = (a, b, c) => (f._sqlite3_result_error = Z.ga)(a, b, c);
+      f._sqlite3_result_int = (a, b) => (f._sqlite3_result_int = Z.ha)(a, b);
+      f._sqlite3_result_int64 = (a, b) => (f._sqlite3_result_int64 = Z.ia)(a, b);
+      f._sqlite3_result_null = (a) => (f._sqlite3_result_null = Z.ja)(a);
+      f._sqlite3_result_text = (a, b, c, d) => (f._sqlite3_result_text = Z.ka)(a, b, c, d);
+      f._sqlite3_aggregate_context = (a, b) => (f._sqlite3_aggregate_context = Z.la)(a, b);
+      f._sqlite3_column_count = (a) => (f._sqlite3_column_count = Z.ma)(a);
+      f._sqlite3_data_count = (a) => (f._sqlite3_data_count = Z.na)(a);
+      f._sqlite3_column_blob = (a, b) => (f._sqlite3_column_blob = Z.oa)(a, b);
+      f._sqlite3_column_bytes = (a, b) => (f._sqlite3_column_bytes = Z.pa)(a, b);
+      f._sqlite3_column_double = (a, b) => (f._sqlite3_column_double = Z.qa)(a, b);
+      f._sqlite3_bind_blob = (a, b, c, d, e) => (f._sqlite3_bind_blob = Z.ra)(a, b, c, d, e);
+      f._sqlite3_bind_double = (a, b, c) => (f._sqlite3_bind_double = Z.sa)(a, b, c);
+      f._sqlite3_bind_int = (a, b, c) => (f._sqlite3_bind_int = Z.ta)(a, b, c);
+      f._sqlite3_bind_text = (a, b, c, d, e) => (f._sqlite3_bind_text = Z.ua)(a, b, c, d, e);
+      f._sqlite3_bind_parameter_index = (a, b) => (f._sqlite3_bind_parameter_index = Z.va)(a, b);
+      f._sqlite3_sql = (a) => (f._sqlite3_sql = Z.wa)(a);
+      f._sqlite3_normalized_sql = (a) => (f._sqlite3_normalized_sql = Z.xa)(a);
+      f._sqlite3_changes = (a) => (f._sqlite3_changes = Z.ya)(a);
+      f._sqlite3_close_v2 = (a) => (f._sqlite3_close_v2 = Z.za)(a);
+      f._sqlite3_create_function_v2 = (a, b, c, d, e, h, k, q, w) => (f._sqlite3_create_function_v2 = Z.Aa)(a, b, c, d, e, h, k, q, w);
+      f._sqlite3_update_hook = (a, b, c) => (f._sqlite3_update_hook = Z.Ba)(a, b, c);
+      f._sqlite3_open = (a, b) => (f._sqlite3_open = Z.Ca)(a, b);
+      var ia = f._malloc = (a) => (ia = f._malloc = Z.Da)(a), fa = f._free = (a) => (fa = f._free = Z.Ea)(a);
+      f._RegisterExtensionFunctions = (a) => (f._RegisterExtensionFunctions = Z.Fa)(a);
+      var Db = (a, b) => (Db = Z.Ga)(a, b), Wc = (a, b) => (Wc = Z.Ha)(a, b), wa = (a) => (wa = Z.Ia)(a), z = (a) => (z = Z.Ja)(a), sa = () => (sa = Z.Ka)();
+      f.stackSave = () => sa();
+      f.stackRestore = (a) => wa(a);
+      f.stackAlloc = (a) => z(a);
+      f.cwrap = (a, b, c, d) => {
+        var e = !c || c.every((h) => h === "number" || h === "boolean");
+        return b !== "string" && e && !d ? f["_" + a] : (...h) => Tc(a, b, c, h);
+      };
+      f.addFunction = Aa;
+      f.removeFunction = A;
+      f.UTF8ToString = ua;
+      f.ALLOC_NORMAL = ea;
+      f.allocate = da;
+      f.allocateUTF8OnStack = xa;
+      function Yc() {
+        function a() {
+          f.calledRun = true;
+          if (!La) {
+            if (!f.noFSInit && !Ib) {
+              var b, c;
+              Ib = true;
+              d ??= f.stdin;
+              b ??= f.stdout;
+              c ??= f.stderr;
+              d ? V("stdin", d) : Zb("/dev/tty", "/dev/stdin");
+              b ? V("stdout", null, b) : Zb("/dev/tty", "/dev/stdout");
+              c ? V("stderr", null, c) : Zb("/dev/tty1", "/dev/stderr");
+              oa("/dev/stdin", 0);
+              oa("/dev/stdout", 1);
+              oa("/dev/stderr", 1);
+            }
+            Z.N();
+            Jb = false;
+            f.onRuntimeInitialized?.();
+            if (f.postRun)
+              for (typeof f.postRun == "function" && (f.postRun = [f.postRun]);f.postRun.length; ) {
+                var d = f.postRun.shift();
+                $a.unshift(d);
+              }
+            Za($a);
+          }
+        }
+        if (0 < K)
+          Sa = Yc;
+        else {
+          if (f.preRun)
+            for (typeof f.preRun == "function" && (f.preRun = [f.preRun]);f.preRun.length; )
+              bb();
+          Za(ab);
+          0 < K ? Sa = Yc : f.setStatus ? (f.setStatus("Running..."), setTimeout(() => {
+            setTimeout(() => f.setStatus(""), 1);
+            a();
+          }, 1)) : a();
+        }
+      }
+      if (f.preInit)
+        for (typeof f.preInit == "function" && (f.preInit = [f.preInit]);0 < f.preInit.length; )
+          f.preInit.pop()();
+      Yc();
+      return Module;
+    });
+    return initSqlJsPromise;
+  };
+  if (typeof exports === "object" && typeof module === "object") {
+    module.exports = initSqlJs;
+    module.exports.default = initSqlJs;
+  } else if (typeof define === "function" && define["amd"]) {
+    define([], function() {
+      return initSqlJs;
+    });
+  } else if (typeof exports === "object") {
+    exports["Module"] = initSqlJs;
+  }
+});
+
+// src/db.ts
+var import_sql = __toESM(require_sql_wasm(), 1);
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from "fs";
+var DATA_DIR = join(homedir(), ".ran");
+var DB_PATH = join(DATA_DIR, "history.db");
+var _db = null;
+var _dbPath = null;
+function initSchema(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS commands (
+      id INTEGER PRIMARY KEY,
+      tool_use_id TEXT UNIQUE,
+      command TEXT NOT NULL,
+      description TEXT,
+      cwd TEXT,
+      stdout TEXT,
+      stderr TEXT,
+      is_error INTEGER DEFAULT 0,
+      timestamp TEXT,
+      session_id TEXT
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS indexed_files (
+      file_path TEXT PRIMARY KEY,
+      last_byte_offset INTEGER DEFAULT 0,
+      last_modified INTEGER DEFAULT 0
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_commands_command ON commands(command)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_commands_timestamp ON commands(timestamp)`);
+}
+async function createDb(dbPath) {
+  const SQL = await import_sql.default();
+  if (dbPath === ":memory:") {
+    const db2 = new SQL.Database;
+    initSchema(db2);
+    return db2;
+  }
+  const path = dbPath ?? DB_PATH;
+  if (!existsSync(DATA_DIR)) {
+    mkdirSync(DATA_DIR, { recursive: true });
+  }
+  let db;
+  if (existsSync(path)) {
+    const buffer = readFileSync(path);
+    db = new SQL.Database(buffer);
+  } else {
+    db = new SQL.Database;
+  }
+  initSchema(db);
+  return db;
+}
+async function getDb() {
+  if (!_db) {
+    _db = await createDb();
+    _dbPath = DB_PATH;
+  }
+  return _db;
+}
+function saveDb(db, path) {
+  const savePath = path ?? _dbPath ?? DB_PATH;
+  const dir = savePath.substring(0, savePath.lastIndexOf("/"));
+  if (dir && !existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const data = db.export();
+  const buffer = Buffer.from(data);
+  writeFileSync(savePath, buffer);
+}
+async function insertCommand(cmd, db) {
+  const database = db ?? await getDb();
+  database.run(`INSERT OR IGNORE INTO commands
+    (tool_use_id, command, description, cwd, stdout, stderr, is_error, timestamp, session_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    cmd.tool_use_id,
+    cmd.command,
+    cmd.description,
+    cmd.cwd,
+    cmd.stdout,
+    cmd.stderr,
+    cmd.is_error,
+    cmd.timestamp,
+    cmd.session_id
+  ]);
+  if (!db)
+    saveDb(database);
+}
+async function updateIndexedFile(filePath, byteOffset, mtime, db) {
+  const database = db ?? await getDb();
+  database.run(`INSERT OR REPLACE INTO indexed_files (file_path, last_byte_offset, last_modified)
+    VALUES (?, ?, ?)`, [filePath, byteOffset, mtime]);
+  if (!db)
+    saveDb(database);
+}
+async function getIndexedFile(filePath, db) {
+  const database = db ?? await getDb();
+  const stmt = database.prepare(`SELECT * FROM indexed_files WHERE file_path = ?`);
+  stmt.bind([filePath]);
+  if (stmt.step()) {
+    const row = stmt.getAsObject();
+    stmt.free();
+    return row;
+  }
+  stmt.free();
+  return null;
+}
+async function searchCommands(pattern, useRegex, cwd, db) {
+  const database = db ?? await getDb();
+  if (useRegex) {
+    const results2 = [];
+    const stmt2 = database.prepare(`SELECT * FROM commands ORDER BY timestamp DESC`);
+    const regex = new RegExp(pattern, "i");
+    while (stmt2.step()) {
+      const row = stmt2.getAsObject();
+      if (regex.test(row.command) && (!cwd || row.cwd === cwd)) {
+        results2.push(row);
+      }
+    }
+    stmt2.free();
+    return results2;
+  }
+  const results = [];
+  const sql = cwd ? `SELECT * FROM commands WHERE command LIKE ? AND cwd = ? ORDER BY timestamp DESC` : `SELECT * FROM commands WHERE command LIKE ? ORDER BY timestamp DESC`;
+  const params = cwd ? [`%${pattern}%`, cwd] : [`%${pattern}%`];
+  const stmt = database.prepare(sql);
+  stmt.bind(params);
+  while (stmt.step()) {
+    results.push(stmt.getAsObject());
+  }
+  stmt.free();
+  return results;
+}
+async function listCommands(limit = 20, db) {
+  const database = db ?? await getDb();
+  const results = [];
+  const stmt = database.prepare(`SELECT * FROM commands ORDER BY timestamp DESC LIMIT ?`);
+  stmt.bind([limit]);
+  while (stmt.step()) {
+    results.push(stmt.getAsObject());
+  }
+  stmt.free();
+  return results;
+}
+async function getStats(db) {
+  const database = db ?? await getDb();
+  const cmdStmt = database.prepare(`SELECT COUNT(*) as count FROM commands`);
+  cmdStmt.step();
+  const commands = cmdStmt.getAsObject();
+  cmdStmt.free();
+  const fileStmt = database.prepare(`SELECT COUNT(*) as count FROM indexed_files`);
+  fileStmt.step();
+  const files = fileStmt.getAsObject();
+  fileStmt.free();
+  return {
+    totalCommands: commands.count,
+    indexedFiles: files.count
+  };
+}
+
+// src/sync.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { statSync, readFileSync as readFileSync2, readdirSync, existsSync as existsSync2 } from "fs";
+var CLAUDE_PROJECTS_DIR = join2(homedir2(), ".claude", "projects");
+function parseJsonlContent(content, sessionId = null) {
+  const lines = content.split(`
+`);
+  const entries = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      entries.push(JSON.parse(trimmed));
+    } catch {}
+  }
+  return extractCommands(entries, sessionId);
+}
+function extractCommands(entries, sessionId = null) {
+  const commands = [];
+  const pendingToolUses = new Map;
+  for (const entry of entries) {
+    if (entry.type === "assistant" && Array.isArray(entry.message.content)) {
+      for (const item of entry.message.content) {
+        if (item.type === "tool_use" && item.name === "Bash") {
+          const toolUse = item;
+          if (toolUse.input?.command) {
+            pendingToolUses.set(toolUse.id, {
+              toolUse,
+              cwd: entry.cwd,
+              timestamp: entry.timestamp
+            });
+          }
+        }
+      }
+    }
+    if (entry.type === "user" && Array.isArray(entry.message.content)) {
+      for (const item of entry.message.content) {
+        if (item.type === "tool_result") {
+          const toolResult = item;
+          const pending = pendingToolUses.get(toolResult.tool_use_id);
+          if (pending) {
+            commands.push({
+              tool_use_id: toolResult.tool_use_id,
+              command: pending.toolUse.input.command,
+              description: pending.toolUse.input.description ?? null,
+              cwd: pending.cwd ?? null,
+              stdout: entry.toolUseResult?.stdout ?? toolResult.content ?? null,
+              stderr: entry.toolUseResult?.stderr ?? null,
+              is_error: toolResult.is_error ? 1 : 0,
+              timestamp: pending.timestamp ?? null,
+              session_id: sessionId
+            });
+            pendingToolUses.delete(toolResult.tool_use_id);
+          }
+        }
+      }
+    }
+  }
+  return commands;
+}
+async function sync(options = {}) {
+  const { force = false, db, projectsDir = CLAUDE_PROJECTS_DIR } = options;
+  const database = db ?? await getDb();
+  const result = {
+    filesScanned: 0,
+    newCommands: 0,
+    errors: []
+  };
+  if (!existsSync2(projectsDir)) {
+    result.errors.push(`Claude projects directory not found: ${projectsDir}`);
+    return result;
+  }
+  const jsonlFiles = [];
+  const projectDirs = readdirSync(projectsDir);
+  for (const dir of projectDirs) {
+    const projectPath = join2(projectsDir, dir);
+    try {
+      const stat = statSync(projectPath);
+      if (stat.isDirectory()) {
+        const files = readdirSync(projectPath);
+        for (const file of files) {
+          if (file.endsWith(".jsonl")) {
+            jsonlFiles.push(join2(projectPath, file));
+          }
+        }
+      }
+    } catch (e) {}
+  }
+  for (const filePath of jsonlFiles) {
+    result.filesScanned++;
+    try {
+      const stat = statSync(filePath);
+      const indexed = await getIndexedFile(filePath, database);
+      if (!force && indexed && indexed.last_byte_offset >= stat.size) {
+        continue;
+      }
+      const startOffset = force ? 0 : indexed?.last_byte_offset ?? 0;
+      const newCommands = await indexFile(filePath, startOffset, database);
+      result.newCommands += newCommands;
+      await updateIndexedFile(filePath, stat.size, stat.mtimeMs, database);
+    } catch (e) {
+      result.errors.push(`Error processing ${filePath}: ${e}`);
+    }
+  }
+  if (!db) {
+    saveDb(database);
+  }
+  return result;
+}
+async function indexFile(filePath, startOffset, db) {
+  const content = readFileSync2(filePath, "utf-8");
+  const lines = content.split(`
+`);
+  let bytePos = 0;
+  let startLine = 0;
+  if (startOffset > 0) {
+    for (let i = 0;i < lines.length; i++) {
+      const lineBytes = Buffer.byteLength(lines[i], "utf-8") + 1;
+      if (bytePos + lineBytes > startOffset) {
+        startLine = i;
+        break;
+      }
+      bytePos += lineBytes;
+    }
+  }
+  const newContent = lines.slice(startLine).join(`
+`);
+  const sessionId = filePath.split("/").pop()?.replace(".jsonl", "") ?? null;
+  const commands = parseJsonlContent(newContent, sessionId);
+  for (const cmd of commands) {
+    await insertCommand(cmd, db);
+  }
+  return commands.length;
+}
+
+// src/format.ts
+function formatCommand(cmd) {
+  const time = cmd.timestamp ? new Date(cmd.timestamp).toLocaleString() : "unknown";
+  const status = cmd.is_error ? "\x1B[31m[error]\x1B[0m" : "\x1B[32m[ok]\x1B[0m";
+  console.log(`${status} \x1B[36m${cmd.command}\x1B[0m`);
+  if (cmd.description) {
+    console.log(`   \x1B[90m${cmd.description}\x1B[0m`);
+  }
+  console.log(`   \x1B[90m${time} | ${cmd.cwd ?? "unknown dir"}\x1B[0m`);
+  console.log();
+}
+
+// src/commands/search.ts
+async function search(pattern, options = {}) {
+  if (!options.noSync) {
+    await sync();
+  }
+  const results = await searchCommands(pattern, options.regex ?? false, options.cwd);
+  const limited = options.limit ? results.slice(0, options.limit) : results;
+  if (limited.length === 0) {
+    console.log("No commands found matching:", pattern);
+    return;
+  }
+  console.log(`Found ${results.length} command(s)${options.limit && results.length > options.limit ? ` (showing ${options.limit})` : ""}:
+`);
+  for (const cmd of limited) {
+    formatCommand(cmd);
+  }
+}
+
+// src/commands/list.ts
+async function list(options = {}) {
+  if (!options.noSync) {
+    await sync();
+  }
+  const limit = options.limit ?? 20;
+  const results = await listCommands(limit);
+  if (results.length === 0) {
+    console.log("No commands in history.");
+    return;
+  }
+  console.log(`Last ${results.length} command(s):
+`);
+  for (const cmd of results) {
+    formatCommand(cmd);
+  }
+}
+
+// src/commands/syncCmd.ts
+async function syncCommand(options = {}) {
+  console.log(options.force ? "Force re-indexing all sessions..." : "Syncing new commands...");
+  const result = await sync({ force: options.force });
+  console.log(`
+Scanned ${result.filesScanned} file(s)`);
+  console.log(`Indexed ${result.newCommands} new command(s)`);
+  if (result.errors.length > 0) {
+    console.log(`
+Errors:`);
+    for (const err of result.errors) {
+      console.log(`  - ${err}`);
+    }
+  }
+  const stats = await getStats();
+  console.log(`
+Total: ${stats.totalCommands} commands from ${stats.indexedFiles} session files`);
+}
+
+// src/commands/onboard.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var MARKER = "<!-- ran:onboard -->";
+var RAN_SECTION = `${MARKER}
+## ran - Claude Code bash history
+
+Use the \`ran\` CLI to search commands from previous Claude Code sessions:
+
+- \`ran search <pattern>\` - Search by substring or regex (\`--regex\`)
+- \`ran list\` - Show recent commands
+- \`ran search "" --cwd /path\` - Filter by directory
+
+Example: "What docker command did you run?" → \`ran search docker\`
+`;
+function onboard(options = {}) {
+  const claudeDir = join3(homedir3(), ".claude");
+  const targetFile = join3(claudeDir, "CLAUDE.md");
+  if (!existsSync3(claudeDir)) {
+    mkdirSync2(claudeDir, { recursive: true });
+  }
+  let existingContent = "";
+  if (existsSync3(targetFile)) {
+    existingContent = readFileSync3(targetFile, "utf-8");
+  }
+  if (existingContent.includes(MARKER)) {
+    if (!options.force) {
+      console.log(`ran section already exists in ${targetFile}`);
+      console.log("Use --force to update it");
+      return;
+    }
+    const markerIndex = existingContent.indexOf(MARKER);
+    const nextSectionMatch = existingContent.slice(markerIndex + MARKER.length).match(/\n## /);
+    if (nextSectionMatch && nextSectionMatch.index !== undefined) {
+      const endIndex = markerIndex + MARKER.length + nextSectionMatch.index;
+      existingContent = existingContent.slice(0, markerIndex) + existingContent.slice(endIndex);
+    } else {
+      existingContent = existingContent.slice(0, markerIndex);
+    }
+  }
+  const newContent = existingContent ? existingContent.trimEnd() + `
+
+` + RAN_SECTION : RAN_SECTION;
+  writeFileSync2(targetFile, newContent);
+  const action = existingContent ? "Updated" : "Created";
+  console.log(`${action} ${targetFile} with ran section`);
+}
+
+// src/cli.ts
+function parseArgs(args) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--regex" || arg === "-r") {
+      flags.regex = true;
+    } else if (arg === "--force" || arg === "-f") {
+      flags.force = true;
+    } else if (arg === "--no-sync") {
+      flags.noSync = true;
+    } else if (arg === "--cwd" && args[i + 1]) {
+      flags.cwd = args[++i];
+    } else if ((arg === "--limit" || arg === "-n") && args[i + 1]) {
+      flags.limit = args[++i];
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function printHelp() {
+  console.log(`
+\x1B[1mran\x1B[0m - Claude Code bash history
+
+\x1B[1mUSAGE:\x1B[0m
+  ran <command> [options]
+
+\x1B[1mCOMMANDS:\x1B[0m
+  search <pattern>   Search command history
+    --regex, -r      Use regex pattern
+    --cwd <path>     Filter by working directory
+    --limit, -n <N>  Limit results
+    --no-sync        Skip auto-sync
+
+  list               List recent commands
+    --limit, -n <N>  Number of commands (default: 20)
+    --no-sync        Skip auto-sync
+
+  sync               Sync command history from Claude sessions
+    --force, -f      Force re-index all sessions
+
+  onboard            Add ran section to ~/.claude/CLAUDE.md
+    --force, -f      Update existing section
+
+\x1B[1mEXAMPLES:\x1B[0m
+  ran search docker
+  ran search "git.*main" --regex
+  ran search npm --cwd /projects/myapp
+  ran list --limit 50
+  ran sync --force
+`);
+}
+async function main() {
+  const { flags, positional } = parseArgs(args.slice(1));
+  switch (command) {
+    case "search":
+    case "s":
+      if (positional.length === 0) {
+        console.error("Error: search requires a pattern");
+        process.exit(1);
+      }
+      await search(positional[0], {
+        regex: flags.regex,
+        cwd: flags.cwd,
+        limit: flags.limit ? parseInt(flags.limit, 10) : undefined,
+        noSync: flags.noSync
+      });
+      break;
+    case "list":
+    case "ls":
+    case "l":
+      await list({
+        limit: flags.limit ? parseInt(flags.limit, 10) : undefined,
+        noSync: flags.noSync
+      });
+      break;
+    case "sync":
+      await syncCommand({
+        force: flags.force
+      });
+      break;
+    case "onboard":
+      onboard({
+        force: flags.force
+      });
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});