summitjs 0.1.0

package/dist/summit.js

@@ -0,0 +1,3304 @@
+// src/reactivity/effect.ts
+var activeEffect;
+var effectStack = [];
+var batchDepth = 0;
+var pendingEffects = /* @__PURE__ */ new Set();
+function effect(fn, options = {}) {
+  const runner = createReactiveEffect(fn, options);
+  if (!options.lazy) runner();
+  return runner;
+}
+function createReactiveEffect(fn, options) {
+  const runner = function reactiveEffect() {
+    if (!runner.active) return fn();
+    if (effectStack.includes(runner)) return void 0;
+    cleanupDeps(runner);
+    try {
+      effectStack.push(runner);
+      activeEffect = runner;
+      return fn();
+    } finally {
+      effectStack.pop();
+      activeEffect = effectStack[effectStack.length - 1];
+    }
+  };
+  runner.deps = [];
+  runner.active = true;
+  runner.scheduler = options.scheduler;
+  runner.onStop = options.onStop;
+  runner.raw = fn;
+  return runner;
+}
+function cleanupDeps(runner) {
+  const { deps } = runner;
+  for (const dep of deps) dep.delete(runner);
+  deps.length = 0;
+}
+function stop(runner) {
+  if (runner.active) {
+    cleanupDeps(runner);
+    runner.onStop?.();
+    runner.active = false;
+  }
+}
+function track(dep) {
+  if (activeEffect) {
+    if (!dep.has(activeEffect)) {
+      dep.add(activeEffect);
+      activeEffect.deps.push(dep);
+    }
+  }
+}
+function trigger(dep) {
+  const effects = [...dep];
+  for (const eff of effects) {
+    if (eff === activeEffect) continue;
+    if (batchDepth > 0) {
+      pendingEffects.add(eff);
+      continue;
+    }
+    runEffect(eff);
+  }
+}
+function runEffect(eff) {
+  if (eff.scheduler) eff.scheduler();
+  else eff();
+}
+function untrack(fn) {
+  const prev = activeEffect;
+  activeEffect = void 0;
+  try {
+    return fn();
+  } finally {
+    activeEffect = prev;
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    if (--batchDepth === 0) flushBatch();
+  }
+}
+function flushBatch() {
+  if (pendingEffects.size === 0) return;
+  const effects = [...pendingEffects];
+  pendingEffects.clear();
+  for (const eff of effects) {
+    if (eff.active) runEffect(eff);
+  }
+}
+
+// src/reactivity/signal.ts
+function signal(initial) {
+  let value = initial;
+  const dep = /* @__PURE__ */ new Set();
+  const read = function() {
+    track(dep);
+    return value;
+  };
+  read.set = (next) => {
+    const nextValue = typeof next === "function" ? next(value) : next;
+    if (!Object.is(nextValue, value)) {
+      value = nextValue;
+      trigger(dep);
+    }
+  };
+  read.peek = () => value;
+  return read;
+}
+function isSignal(x) {
+  return typeof x === "function" && typeof x.set === "function" && typeof x.peek === "function";
+}
+
+// src/reactivity/computed.ts
+function computed(getter) {
+  let value;
+  let dirty = true;
+  const dep = /* @__PURE__ */ new Set();
+  const runner = effect(getter, {
+    lazy: true,
+    scheduler: () => {
+      if (!dirty) {
+        dirty = true;
+        trigger(dep);
+      }
+    }
+  });
+  const read = function() {
+    if (dirty) {
+      value = runner();
+      dirty = false;
+    }
+    track(dep);
+    return value;
+  };
+  read.peek = () => {
+    if (dirty) {
+      value = runner();
+      dirty = false;
+    }
+    return value;
+  };
+  return read;
+}
+
+// src/reactivity/reactive.ts
+var RAW = /* @__PURE__ */ Symbol("summit.raw");
+var ITERATE_KEY = /* @__PURE__ */ Symbol("summit.iterate");
+var targetMap = /* @__PURE__ */ new WeakMap();
+var proxyMap = /* @__PURE__ */ new WeakMap();
+function getDep(target, key) {
+  let depsMap = targetMap.get(target);
+  if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+  let dep = depsMap.get(key);
+  if (!dep) depsMap.set(key, dep = /* @__PURE__ */ new Set());
+  return dep;
+}
+function trackProp(target, key) {
+  track(getDep(target, key));
+}
+function triggerProp(target, key) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) return;
+  const dep = depsMap.get(key);
+  if (dep) trigger(dep);
+}
+function isObject(x) {
+  return x !== null && typeof x === "object";
+}
+function isPlainObject(o) {
+  const proto = Object.getPrototypeOf(o);
+  return proto === Object.prototype || proto === null;
+}
+function shouldWrap(o) {
+  return isObject(o) && (Array.isArray(o) || isPlainObject(o));
+}
+var handlers = {
+  get(target, key, receiver) {
+    if (key === RAW) return target;
+    const result = Reflect.get(target, key, receiver);
+    if (typeof key === "symbol") return result;
+    trackProp(target, key);
+    if (shouldWrap(result)) return reactive(result);
+    return result;
+  },
+  set(target, key, value, receiver) {
+    const raw = isObject(value) ? toRaw(value) : value;
+    const isArray = Array.isArray(target);
+    const hadKey = isArray ? Number(key) < target.length : Object.prototype.hasOwnProperty.call(target, key);
+    const oldValue = target[key];
+    const result = Reflect.set(target, key, raw, receiver);
+    if (!hadKey) {
+      triggerProp(target, key);
+      triggerProp(target, isArray ? "length" : ITERATE_KEY);
+    } else if (!Object.is(oldValue, raw)) {
+      triggerProp(target, key);
+    }
+    return result;
+  },
+  has(target, key) {
+    trackProp(target, key);
+    return Reflect.has(target, key);
+  },
+  deleteProperty(target, key) {
+    const had = Object.prototype.hasOwnProperty.call(target, key);
+    const result = Reflect.deleteProperty(target, key);
+    if (had && result) {
+      triggerProp(target, key);
+      triggerProp(target, ITERATE_KEY);
+    }
+    return result;
+  },
+  ownKeys(target) {
+    trackProp(target, Array.isArray(target) ? "length" : ITERATE_KEY);
+    return Reflect.ownKeys(target);
+  }
+};
+function reactive(target) {
+  if (!shouldWrap(target)) return target;
+  if (target[RAW]) return target;
+  const existing = proxyMap.get(target);
+  if (existing) return existing;
+  const proxy = new Proxy(target, handlers);
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function toRaw(observed) {
+  const raw = observed && observed[RAW];
+  return raw ? toRaw(raw) : observed;
+}
+function isReactive(x) {
+  return isObject(x) && Boolean(x[RAW]);
+}
+
+// src/reactivity/scheduler.ts
+var queue = /* @__PURE__ */ new Set();
+var flushing = false;
+var flushPromise = null;
+var resolved = Promise.resolve();
+function queueJob(job) {
+  queue.add(job);
+  if (!flushing) {
+    flushing = true;
+    flushPromise = resolved.then(flushJobs);
+  }
+}
+function flushJobs() {
+  const jobs = [...queue];
+  queue.clear();
+  flushing = false;
+  flushPromise = null;
+  for (const job of jobs) job();
+}
+function nextTick(callback) {
+  const p = flushPromise ?? resolved;
+  return callback ? p.then(() => void callback()) : p.then(() => void 0);
+}
+
+// src/reactivity/index.ts
+function domEffect(fn) {
+  let runner;
+  runner = effect(fn, {
+    lazy: true,
+    scheduler: () => queueJob(runner)
+  });
+  runner();
+  return () => stop(runner);
+}
+
+// src/registry/registry.ts
+var directives = /* @__PURE__ */ new Map();
+var magics = /* @__PURE__ */ new Map();
+var dataProviders = /* @__PURE__ */ new Map();
+var storeRoot = reactive({});
+var binds = /* @__PURE__ */ new Map();
+var DEFAULT_PRIORITY = 100;
+function registerDirective(name, handler, priority = DEFAULT_PRIORITY) {
+  directives.set(name, { handler, priority });
+}
+function getDirective(name) {
+  return directives.get(name);
+}
+function directiveNames() {
+  return [...directives.keys()];
+}
+function registerMagic(name, factory) {
+  magics.set(name, factory);
+}
+function getMagic(name) {
+  return magics.get(name);
+}
+function magicNames() {
+  return [...magics.keys()];
+}
+function registerData(name, provider) {
+  dataProviders.set(name, provider);
+}
+function getData(name) {
+  return dataProviders.get(name);
+}
+function setStore(name, value) {
+  storeRoot[name] = value;
+}
+function getStore(name) {
+  return storeRoot[name];
+}
+function getStoreRoot() {
+  return storeRoot;
+}
+function registerBind(name, provider) {
+  binds.set(name, provider);
+}
+function getBind(name) {
+  return binds.get(name);
+}
+
+// src/scope/scope.ts
+function createScope(raw) {
+  const proxy = reactive(raw);
+  const descriptors = Object.getOwnPropertyDescriptors(raw);
+  for (const key of Object.keys(descriptors)) {
+    const desc = descriptors[key];
+    if (typeof desc.get === "function") {
+      const getter = desc.get;
+      const setter = desc.set;
+      const cached = computed(() => getter.call(proxy));
+      Object.defineProperty(raw, key, {
+        get: () => cached(),
+        set: setter ? (v) => setter.call(proxy, v) : void 0,
+        enumerable: desc.enumerable,
+        configurable: true
+      });
+    } else if (typeof desc.value === "function") {
+      raw[key] = desc.value.bind(proxy);
+    }
+  }
+  return proxy;
+}
+
+// src/evaluator/lexer.ts
+var PUNCTUATORS = [
+  "...",
+  "===",
+  "!==",
+  "**=",
+  "&&=",
+  "||=",
+  "??=",
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "&&",
+  "||",
+  "??",
+  "?.",
+  "=>",
+  "++",
+  "--",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%=",
+  "**",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  ".",
+  ",",
+  ";",
+  ":",
+  "?",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "<",
+  ">",
+  "=",
+  "!"
+];
+var LexError = class extends Error {
+};
+function isIdentStart(ch) {
+  return /[A-Za-z_$]/.test(ch);
+}
+function isIdentPart(ch) {
+  return /[A-Za-z0-9_$]/.test(ch);
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+function tokenize(input) {
+  const tokens2 = [];
+  let i = 0;
+  const n = input.length;
+  while (i < n) {
+    const ch = input[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (isDigit(ch) || ch === "." && isDigit(input[i + 1] ?? "")) {
+      const start2 = i;
+      if (ch === "0" && (input[i + 1] === "x" || input[i + 1] === "X")) {
+        i += 2;
+        while (i < n && /[0-9a-fA-F]/.test(input[i])) i++;
+      } else {
+        while (i < n && isDigit(input[i])) i++;
+        if (input[i] === ".") {
+          i++;
+          while (i < n && isDigit(input[i])) i++;
+        }
+        if (input[i] === "e" || input[i] === "E") {
+          i++;
+          if (input[i] === "+" || input[i] === "-") i++;
+          while (i < n && isDigit(input[i])) i++;
+        }
+      }
+      tokens2.push({ type: "num", value: input.slice(start2, i), start: start2, end: i });
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const start2 = i;
+      const quote = ch;
+      i++;
+      let value = "";
+      while (i < n && input[i] !== quote) {
+        if (input[i] === "\\") {
+          value += readEscape(input, i);
+          i += 2;
+        } else {
+          value += input[i];
+          i++;
+        }
+      }
+      if (i >= n) throw new LexError(`Unterminated string in expression: ${input}`);
+      i++;
+      tokens2.push({ type: "str", value, start: start2, end: i });
+      continue;
+    }
+    if (ch === "`") {
+      const start2 = i;
+      i++;
+      let raw = "";
+      let depth = 0;
+      while (i < n) {
+        const c = input[i];
+        if (c === "\\") {
+          raw += input[i] + (input[i + 1] ?? "");
+          i += 2;
+          continue;
+        }
+        if (c === "`" && depth === 0) break;
+        if (c === "$" && input[i + 1] === "{") {
+          depth++;
+          raw += "${";
+          i += 2;
+          continue;
+        }
+        if (c === "}" && depth > 0) {
+          depth--;
+          raw += "}";
+          i++;
+          continue;
+        }
+        raw += c;
+        i++;
+      }
+      if (i >= n) throw new LexError(`Unterminated template literal: ${input}`);
+      i++;
+      tokens2.push({ type: "tmpl", value: raw, raw, start: start2, end: i });
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      const start2 = i;
+      i++;
+      while (i < n && isIdentPart(input[i])) i++;
+      tokens2.push({ type: "ident", value: input.slice(start2, i), start: start2, end: i });
+      continue;
+    }
+    let matched = false;
+    for (const p of PUNCTUATORS) {
+      if (input.startsWith(p, i)) {
+        tokens2.push({ type: "punc", value: p, start: i, end: i + p.length });
+        i += p.length;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      throw new LexError(`Unexpected character '${ch}' in expression: ${input}`);
+    }
+  }
+  tokens2.push({ type: "eof", value: "", start: n, end: n });
+  return tokens2;
+}
+function readEscape(input, at) {
+  const next = input[at + 1];
+  switch (next) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    case "b":
+      return "\b";
+    case "f":
+      return "\f";
+    case "v":
+      return "\v";
+    case "0":
+      return "\0";
+    case "\\":
+      return "\\";
+    case "'":
+      return "'";
+    case '"':
+      return '"';
+    case "`":
+      return "`";
+    default:
+      return next ?? "";
+  }
+}
+
+// src/evaluator/parser.ts
+var ParseError = class extends Error {
+};
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "this",
+  "typeof",
+  "void",
+  "in",
+  "instanceof",
+  "if",
+  "else",
+  "return",
+  "let",
+  "const",
+  "var",
+  "for",
+  "of",
+  "while",
+  "break",
+  "continue"
+]);
+var BINARY_PREC = {
+  "??": 1,
+  "||": 2,
+  "&&": 3,
+  "==": 7,
+  "!=": 7,
+  "===": 7,
+  "!==": 7,
+  "<": 8,
+  ">": 8,
+  "<=": 8,
+  ">=": 8,
+  in: 8,
+  instanceof: 8,
+  "+": 10,
+  "-": 10,
+  "*": 11,
+  "/": 11,
+  "%": 11,
+  "**": 12
+};
+var ASSIGN_OPS = /* @__PURE__ */ new Set(["=", "+=", "-=", "*=", "/=", "%=", "**=", "&&=", "||=", "??="]);
+var Parser = class {
+  constructor(source) {
+    this.pos = 0;
+    this.tokens = tokenize(source);
+  }
+  peek(offset = 0) {
+    return this.tokens[this.pos + offset] ?? this.tokens[this.tokens.length - 1];
+  }
+  next() {
+    return this.tokens[this.pos++] ?? this.tokens[this.tokens.length - 1];
+  }
+  isPunc(value, offset = 0) {
+    const t = this.peek(offset);
+    return t.type === "punc" && t.value === value;
+  }
+  isKeyword(value, offset = 0) {
+    const t = this.peek(offset);
+    return t.type === "ident" && t.value === value;
+  }
+  eatPunc(value) {
+    if (!this.isPunc(value)) {
+      throw new ParseError(`Expected '${value}' but found '${this.peek().value || "end of input"}'`);
+    }
+    this.pos++;
+  }
+  atEnd() {
+    return this.peek().type === "eof";
+  }
+  // --- Entry points ---
+  parseProgram() {
+    const body = [];
+    while (!this.atEnd()) {
+      if (this.isPunc(";")) {
+        this.pos++;
+        continue;
+      }
+      body.push(this.parseStatement());
+    }
+    return { type: "Program", body };
+  }
+  parseExpressionProgram() {
+    const expr = this.parseExpression();
+    if (!this.atEnd()) {
+      throw new ParseError(`Unexpected trailing input '${this.peek().value}'`);
+    }
+    return { type: "Program", body: [{ type: "ExpressionStatement", expression: expr }] };
+  }
+  // --- Statements ---
+  parseStatement() {
+    if (this.isPunc("{")) return this.parseBlock();
+    if (this.isKeyword("if")) return this.parseIf();
+    if (this.isKeyword("return")) return this.parseReturn();
+    if (this.isKeyword("let") || this.isKeyword("const") || this.isKeyword("var")) {
+      const decl = this.parseVarDecl();
+      this.consumeSemi();
+      return decl;
+    }
+    if (this.isKeyword("for")) return this.parseFor();
+    if (this.isKeyword("while")) return this.parseWhile();
+    if (this.isKeyword("break")) {
+      this.pos++;
+      this.consumeSemi();
+      return { type: "BreakStatement" };
+    }
+    if (this.isKeyword("continue")) {
+      this.pos++;
+      this.consumeSemi();
+      return { type: "ContinueStatement" };
+    }
+    const expression = this.parseExpression();
+    this.consumeSemi();
+    return { type: "ExpressionStatement", expression };
+  }
+  consumeSemi() {
+    if (this.isPunc(";")) this.pos++;
+  }
+  parseBlock() {
+    this.eatPunc("{");
+    const body = [];
+    while (!this.isPunc("}") && !this.atEnd()) {
+      if (this.isPunc(";")) {
+        this.pos++;
+        continue;
+      }
+      body.push(this.parseStatement());
+    }
+    this.eatPunc("}");
+    return { type: "BlockStatement", body };
+  }
+  parseIf() {
+    this.pos++;
+    this.eatPunc("(");
+    const test = this.parseExpression();
+    this.eatPunc(")");
+    const consequent = this.parseStatement();
+    let alternate = null;
+    if (this.isKeyword("else")) {
+      this.pos++;
+      alternate = this.parseStatement();
+    }
+    return { type: "IfStatement", test, consequent, alternate };
+  }
+  parseReturn() {
+    this.pos++;
+    let argument = null;
+    if (!this.isPunc(";") && !this.isPunc("}") && !this.atEnd()) {
+      argument = this.parseExpression();
+    }
+    this.consumeSemi();
+    return { type: "ReturnStatement", argument };
+  }
+  parseVarDecl() {
+    const kind = this.next().value;
+    const declarations = [];
+    do {
+      const id2 = this.parsePattern();
+      let init2 = null;
+      if (this.isPunc("=")) {
+        this.pos++;
+        init2 = this.parseAssignment();
+      }
+      declarations.push({ id: id2, init: init2 });
+    } while (this.isPunc(",") && (this.pos++, true));
+    return { type: "VariableDeclaration", kind, declarations };
+  }
+  parseFor() {
+    this.pos++;
+    this.eatPunc("(");
+    let init2 = null;
+    if (this.isKeyword("let") || this.isKeyword("const") || this.isKeyword("var")) {
+      const kind = this.next().value;
+      const pattern = this.parsePattern();
+      if (this.isKeyword("of")) {
+        this.pos++;
+        const right = this.parseExpression();
+        this.eatPunc(")");
+        const body2 = this.parseStatement();
+        return {
+          type: "ForOfStatement",
+          left: { type: "VariableDeclaration", kind, declarations: [{ id: pattern, init: null }] },
+          right,
+          body: body2
+        };
+      }
+      let declInit = null;
+      if (this.isPunc("=")) {
+        this.pos++;
+        declInit = this.parseAssignment();
+      }
+      const declarations = [{ id: pattern, init: declInit }];
+      while (this.isPunc(",")) {
+        this.pos++;
+        const id2 = this.parsePattern();
+        let vi = null;
+        if (this.isPunc("=")) {
+          this.pos++;
+          vi = this.parseAssignment();
+        }
+        declarations.push({ id: id2, init: vi });
+      }
+      init2 = { type: "VariableDeclaration", kind, declarations };
+    } else if (!this.isPunc(";")) {
+      init2 = this.parseExpression();
+    }
+    this.eatPunc(";");
+    const test = this.isPunc(";") ? null : this.parseExpression();
+    this.eatPunc(";");
+    const update = this.isPunc(")") ? null : this.parseExpression();
+    this.eatPunc(")");
+    const body = this.parseStatement();
+    return { type: "ForStatement", init: init2, test, update, body };
+  }
+  parseWhile() {
+    this.pos++;
+    this.eatPunc("(");
+    const test = this.parseExpression();
+    this.eatPunc(")");
+    const body = this.parseStatement();
+    return { type: "WhileStatement", test, body };
+  }
+  // --- Expressions ---
+  parseExpression() {
+    return this.parseAssignment();
+  }
+  parseAssignment() {
+    if (this.isArrowAhead()) return this.parseArrow();
+    const left = this.parseConditional();
+    const t = this.peek();
+    if (t.type === "punc" && ASSIGN_OPS.has(t.value)) {
+      this.pos++;
+      const right = this.parseAssignment();
+      return { type: "AssignmentExpression", operator: t.value, left, right };
+    }
+    return left;
+  }
+  parseConditional() {
+    const test = this.parseBinary(1);
+    if (this.isPunc("?")) {
+      this.pos++;
+      const consequent = this.parseAssignment();
+      this.eatPunc(":");
+      const alternate = this.parseAssignment();
+      return { type: "ConditionalExpression", test, consequent, alternate };
+    }
+    return test;
+  }
+  parseBinary(minPrec) {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const t = this.peek();
+      const op = t.type === "punc" ? t.value : t.type === "ident" && (t.value === "in" || t.value === "instanceof") ? t.value : null;
+      if (op === null) break;
+      const prec = BINARY_PREC[op];
+      if (prec === void 0 || prec < minPrec) break;
+      this.pos++;
+      const rightAssoc = op === "**";
+      const right = this.parseBinary(rightAssoc ? prec : prec + 1);
+      if (op === "&&" || op === "||" || op === "??") {
+        left = { type: "LogicalExpression", operator: op, left, right };
+      } else {
+        left = { type: "BinaryExpression", operator: op, left, right };
+      }
+    }
+    return left;
+  }
+  parseUnary() {
+    const t = this.peek();
+    if (t.type === "punc" && (t.value === "!" || t.value === "-" || t.value === "+")) {
+      this.pos++;
+      return { type: "UnaryExpression", operator: t.value, argument: this.parseUnary() };
+    }
+    if (t.type === "ident" && (t.value === "typeof" || t.value === "void")) {
+      this.pos++;
+      return { type: "UnaryExpression", operator: t.value, argument: this.parseUnary() };
+    }
+    if (t.type === "punc" && (t.value === "++" || t.value === "--")) {
+      this.pos++;
+      return { type: "UpdateExpression", operator: t.value, prefix: true, argument: this.parseUnary() };
+    }
+    return this.parsePostfix();
+  }
+  parsePostfix() {
+    let node = this.parseCallMember();
+    const t = this.peek();
+    if (t.type === "punc" && (t.value === "++" || t.value === "--")) {
+      this.pos++;
+      node = { type: "UpdateExpression", operator: t.value, prefix: false, argument: node };
+    }
+    return node;
+  }
+  parseCallMember() {
+    let node = this.parsePrimary();
+    for (; ; ) {
+      if (this.isPunc(".")) {
+        this.pos++;
+        const name = this.next();
+        node = {
+          type: "MemberExpression",
+          object: node,
+          property: { type: "Identifier", name: name.value },
+          computed: false,
+          optional: false
+        };
+      } else if (this.isPunc("?.")) {
+        this.pos++;
+        if (this.isPunc("(")) {
+          node = { type: "CallExpression", callee: node, arguments: this.parseArguments(), optional: true };
+        } else if (this.isPunc("[")) {
+          this.pos++;
+          const property = this.parseExpression();
+          this.eatPunc("]");
+          node = { type: "MemberExpression", object: node, property, computed: true, optional: true };
+        } else {
+          const name = this.next();
+          node = {
+            type: "MemberExpression",
+            object: node,
+            property: { type: "Identifier", name: name.value },
+            computed: false,
+            optional: true
+          };
+        }
+      } else if (this.isPunc("[")) {
+        this.pos++;
+        const property = this.parseExpression();
+        this.eatPunc("]");
+        node = { type: "MemberExpression", object: node, property, computed: true, optional: false };
+      } else if (this.isPunc("(")) {
+        node = { type: "CallExpression", callee: node, arguments: this.parseArguments(), optional: false };
+      } else {
+        break;
+      }
+    }
+    return node;
+  }
+  parseArguments() {
+    this.eatPunc("(");
+    const args = [];
+    while (!this.isPunc(")") && !this.atEnd()) {
+      if (this.isPunc("...")) {
+        this.pos++;
+        args.push({ type: "SpreadElement", argument: this.parseAssignment() });
+      } else {
+        args.push(this.parseAssignment());
+      }
+      if (this.isPunc(",")) this.pos++;
+      else break;
+    }
+    this.eatPunc(")");
+    return args;
+  }
+  parsePrimary() {
+    const t = this.peek();
+    if (t.type === "num") {
+      this.pos++;
+      const value = t.value.startsWith("0x") || t.value.startsWith("0X") ? parseInt(t.value, 16) : Number(t.value);
+      return { type: "NumberLiteral", value };
+    }
+    if (t.type === "str") {
+      this.pos++;
+      return { type: "StringLiteral", value: t.value };
+    }
+    if (t.type === "tmpl") {
+      this.pos++;
+      return this.parseTemplate(t.raw ?? "");
+    }
+    if (t.type === "ident") {
+      if (t.value === "true" || t.value === "false") {
+        this.pos++;
+        return { type: "BooleanLiteral", value: t.value === "true" };
+      }
+      if (t.value === "null") {
+        this.pos++;
+        return { type: "NullLiteral" };
+      }
+      if (t.value === "undefined") {
+        this.pos++;
+        return { type: "UndefinedLiteral" };
+      }
+      if (t.value === "this") {
+        this.pos++;
+        return { type: "ThisExpression" };
+      }
+      this.pos++;
+      return { type: "Identifier", name: t.value };
+    }
+    if (this.isPunc("(")) {
+      this.pos++;
+      const first = this.parseAssignment();
+      if (this.isPunc(",")) {
+        const expressions = [first];
+        while (this.isPunc(",")) {
+          this.pos++;
+          expressions.push(this.parseAssignment());
+        }
+        this.eatPunc(")");
+        return { type: "SequenceExpression", expressions };
+      }
+      this.eatPunc(")");
+      return first;
+    }
+    if (this.isPunc("[")) {
+      return this.parseArray();
+    }
+    if (this.isPunc("{")) {
+      return this.parseObject();
+    }
+    throw new ParseError(`Unexpected token '${t.value || "end of input"}' in expression`);
+  }
+  parseArray() {
+    this.eatPunc("[");
+    const elements = [];
+    while (!this.isPunc("]") && !this.atEnd()) {
+      if (this.isPunc(",")) {
+        elements.push(null);
+        this.pos++;
+        continue;
+      }
+      if (this.isPunc("...")) {
+        this.pos++;
+        elements.push({ type: "SpreadElement", argument: this.parseAssignment() });
+      } else {
+        elements.push(this.parseAssignment());
+      }
+      if (this.isPunc(",")) this.pos++;
+      else break;
+    }
+    this.eatPunc("]");
+    return { type: "ArrayExpression", elements };
+  }
+  parseObject() {
+    this.eatPunc("{");
+    const properties = [];
+    while (!this.isPunc("}") && !this.atEnd()) {
+      if (this.isPunc("...")) {
+        this.pos++;
+        properties.push({ type: "SpreadElement", argument: this.parseAssignment() });
+      } else {
+        properties.push(this.parseObjectProperty());
+      }
+      if (this.isPunc(",")) this.pos++;
+      else break;
+    }
+    this.eatPunc("}");
+    return { type: "ObjectExpression", properties };
+  }
+  parseObjectProperty() {
+    if ((this.isKeyword("get") || this.isKeyword("set")) && !this.isPunc(":", 1) && !this.isPunc(",", 1) && !this.isPunc("(", 1) && !this.isPunc("}", 1)) {
+      const kind = this.next().value;
+      const { key: key2, computed: computed3 } = this.parsePropertyKey();
+      const fn = this.parseMethodTail();
+      return { key: key2, computed: computed3, value: fn, kind, shorthand: false };
+    }
+    const { key, computed: computed2, keyName } = this.parsePropertyKey();
+    if (this.isPunc("(")) {
+      const fn = this.parseMethodTail();
+      return { key, computed: computed2, value: fn, kind: "method", shorthand: false };
+    }
+    if (this.isPunc(":")) {
+      this.pos++;
+      const value = this.parseAssignment();
+      return { key, computed: computed2, value, kind: "init", shorthand: false };
+    }
+    if (keyName !== null && !computed2) {
+      return { key, computed: computed2, value: { type: "Identifier", name: keyName }, kind: "init", shorthand: true };
+    }
+    throw new ParseError(`Invalid object property near '${this.peek().value}'`);
+  }
+  parsePropertyKey() {
+    if (this.isPunc("[")) {
+      this.pos++;
+      const key = this.parseAssignment();
+      this.eatPunc("]");
+      return { key, computed: true, keyName: null };
+    }
+    const t = this.next();
+    if (t.type === "str") return { key: { type: "StringLiteral", value: t.value }, computed: false, keyName: t.value };
+    if (t.type === "num")
+      return { key: { type: "StringLiteral", value: String(Number(t.value)) }, computed: false, keyName: null };
+    if (t.type === "ident") return { key: { type: "StringLiteral", value: t.value }, computed: false, keyName: t.value };
+    throw new ParseError(`Invalid property key '${t.value}'`);
+  }
+  parseMethodTail() {
+    const params = this.parseParamList();
+    const body = this.parseBlock();
+    return { type: "ArrowFunction", params, body, expression: false };
+  }
+  // --- Arrow functions ---
+  isArrowAhead() {
+    const t = this.peek();
+    if (t.type === "ident" && !KEYWORDS.has(t.value) && this.isPunc("=>", 1)) return true;
+    if (this.isPunc("(")) {
+      let depth = 0;
+      let i = this.pos;
+      for (; i < this.tokens.length; i++) {
+        const tok = this.tokens[i];
+        if (tok.type === "punc" && tok.value === "(") depth++;
+        else if (tok.type === "punc" && tok.value === ")") {
+          depth--;
+          if (depth === 0) break;
+        } else if (tok.type === "eof") return false;
+      }
+      const after = this.tokens[i + 1];
+      return !!after && after.type === "punc" && after.value === "=>";
+    }
+    return false;
+  }
+  parseArrow() {
+    let params;
+    if (this.peek().type === "ident") {
+      params = [{ type: "Identifier", name: this.next().value }];
+    } else {
+      params = this.parseParamList();
+    }
+    this.eatPunc("=>");
+    if (this.isPunc("{")) {
+      const body2 = this.parseBlock();
+      return { type: "ArrowFunction", params, body: body2, expression: false };
+    }
+    const body = this.parseAssignment();
+    return { type: "ArrowFunction", params, body, expression: true };
+  }
+  parseParamList() {
+    this.eatPunc("(");
+    const params = [];
+    while (!this.isPunc(")") && !this.atEnd()) {
+      params.push(this.parsePattern());
+      if (this.isPunc(",")) this.pos++;
+      else break;
+    }
+    this.eatPunc(")");
+    return params;
+  }
+  // --- Patterns ---
+  parsePattern() {
+    let pattern;
+    if (this.isPunc("...")) {
+      this.pos++;
+      return { type: "RestElement", argument: this.parsePattern() };
+    }
+    if (this.isPunc("{")) {
+      pattern = this.parseObjectPattern();
+    } else if (this.isPunc("[")) {
+      pattern = this.parseArrayPattern();
+    } else {
+      const t = this.next();
+      if (t.type !== "ident") throw new ParseError(`Invalid binding target '${t.value}'`);
+      pattern = { type: "Identifier", name: t.value };
+    }
+    if (this.isPunc("=")) {
+      this.pos++;
+      const right = this.parseAssignment();
+      return { type: "AssignmentPattern", left: pattern, right };
+    }
+    return pattern;
+  }
+  parseObjectPattern() {
+    this.eatPunc("{");
+    const properties = [];
+    let rest = null;
+    while (!this.isPunc("}") && !this.atEnd()) {
+      if (this.isPunc("...")) {
+        this.pos++;
+        const t = this.next();
+        rest = { type: "Identifier", name: t.value };
+        break;
+      }
+      const { key, computed: computed2, keyName } = this.parsePropertyKey();
+      let value;
+      if (this.isPunc(":")) {
+        this.pos++;
+        value = this.parsePattern();
+      } else {
+        value = { type: "Identifier", name: keyName ?? "" };
+        if (this.isPunc("=")) {
+          this.pos++;
+          value = { type: "AssignmentPattern", left: value, right: this.parseAssignment() };
+        }
+      }
+      properties.push({ key, value, computed: computed2 });
+      if (this.isPunc(",")) this.pos++;
+      else break;
+    }
+    this.eatPunc("}");
+    return { type: "ObjectPattern", properties, rest };
+  }
+  parseArrayPattern() {
+    this.eatPunc("[");
+    const elements = [];
+    let rest = null;
+    while (!this.isPunc("]") && !this.atEnd()) {
+      if (this.isPunc(",")) {
+        elements.push(null);
+        this.pos++;
+        continue;
+      }
+      if (this.isPunc("...")) {
+        this.pos++;
+        rest = this.parsePattern();
+        break;
+      }
+      elements.push(this.parsePattern());
+      if (this.isPunc(",")) this.pos++;
+      else break;
+    }
+    this.eatPunc("]");
+    return { type: "ArrayPattern", elements, rest };
+  }
+  // --- Template literals ---
+  parseTemplate(raw) {
+    const quasis = [];
+    const expressions = [];
+    let current = "";
+    let i = 0;
+    while (i < raw.length) {
+      if (raw[i] === "$" && raw[i + 1] === "{") {
+        quasis.push(current);
+        current = "";
+        i += 2;
+        let depth = 1;
+        let src = "";
+        while (i < raw.length && depth > 0) {
+          const c = raw[i];
+          if (c === "{") depth++;
+          else if (c === "}") {
+            depth--;
+            if (depth === 0) break;
+          }
+          src += c;
+          i++;
+        }
+        i++;
+        const stmt = parse(src, "expression").body[0];
+        expressions.push(stmt && stmt.type === "ExpressionStatement" ? stmt.expression : { type: "UndefinedLiteral" });
+      } else {
+        current += raw[i];
+        i++;
+      }
+    }
+    quasis.push(current);
+    return { type: "TemplateLiteral", quasis, expressions };
+  }
+};
+var cache = /* @__PURE__ */ new Map();
+function parse(source, mode) {
+  const key = mode + "\0" + source;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const parser = new Parser(source);
+  const program = mode === "expression" ? parser.parseExpressionProgram() : parser.parseProgram();
+  cache.set(key, program);
+  return program;
+}
+
+// src/evaluator/interpreter.ts
+var ReturnSignal = class {
+  constructor(value) {
+    this.value = value;
+  }
+};
+var BreakSignal = class {
+};
+var ContinueSignal = class {
+};
+var LexicalScope = class {
+  constructor(parent) {
+    this.parent = parent;
+    this.vars = /* @__PURE__ */ new Map();
+  }
+  declare(name, value, constant) {
+    this.vars.set(name, { value, constant });
+  }
+  find(name) {
+    let s = this;
+    while (s) {
+      if (s.vars.has(name)) return s;
+      s = s.parent;
+    }
+    return null;
+  }
+  has(name) {
+    return this.find(name) !== null;
+  }
+  get(name) {
+    return this.find(name)?.vars.get(name)?.value;
+  }
+  set(name, value) {
+    const owner = this.find(name);
+    if (!owner) return false;
+    const entry = owner.vars.get(name);
+    if (entry.constant) throw new TypeError(`Assignment to constant '${name}'`);
+    entry.value = value;
+    return true;
+  }
+};
+var GLOBAL_ALLOW = /* @__PURE__ */ new Set([
+  "Math",
+  "JSON",
+  "Date",
+  "Object",
+  "Array",
+  "Number",
+  "String",
+  "Boolean",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Intl",
+  "console",
+  "window",
+  "document",
+  "location",
+  "navigator",
+  "history",
+  "localStorage",
+  "sessionStorage",
+  "setTimeout",
+  "clearTimeout",
+  "setInterval",
+  "clearInterval",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "fetch",
+  "alert",
+  "confirm",
+  "prompt",
+  "structuredClone",
+  "URL",
+  "URLSearchParams",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "NaN",
+  "Infinity"
+]);
+function addGlobals(names) {
+  for (const n of names) GLOBAL_ALLOW.add(n);
+}
+function memberGet(obj, key) {
+  if (obj == null) return void 0;
+  return obj[key];
+}
+var Interpreter = class {
+  constructor(root) {
+    this.root = root;
+  }
+  run(program, thisVal) {
+    const scope = new LexicalScope(null);
+    let result;
+    try {
+      for (const stmt of program.body) {
+        if (stmt.type === "ExpressionStatement") {
+          result = this.evalExpr(stmt.expression, scope, thisVal);
+        } else {
+          this.execStmt(stmt, scope, thisVal);
+        }
+      }
+    } catch (signal2) {
+      if (signal2 instanceof ReturnSignal) return signal2.value;
+      throw signal2;
+    }
+    return result;
+  }
+  // --- Statements ---
+  execBlock(body, scope, thisVal) {
+    for (const stmt of body) this.execStmt(stmt, scope, thisVal);
+  }
+  execStmt(node, scope, thisVal) {
+    switch (node.type) {
+      case "ExpressionStatement":
+        this.evalExpr(node.expression, scope, thisVal);
+        return;
+      case "BlockStatement":
+        this.execBlock(node.body, new LexicalScope(scope), thisVal);
+        return;
+      case "IfStatement":
+        if (this.evalExpr(node.test, scope, thisVal)) this.execStmt(node.consequent, scope, thisVal);
+        else if (node.alternate) this.execStmt(node.alternate, scope, thisVal);
+        return;
+      case "ReturnStatement":
+        throw new ReturnSignal(node.argument ? this.evalExpr(node.argument, scope, thisVal) : void 0);
+      case "VariableDeclaration":
+        for (const decl of node.declarations) {
+          const value = decl.init ? this.evalExpr(decl.init, scope, thisVal) : void 0;
+          this.bindPattern(decl.id, value, scope, node.kind === "const");
+        }
+        return;
+      case "WhileStatement":
+        while (this.evalExpr(node.test, scope, thisVal)) {
+          try {
+            this.execStmt(node.body, new LexicalScope(scope), thisVal);
+          } catch (s) {
+            if (s instanceof BreakSignal) break;
+            if (s instanceof ContinueSignal) continue;
+            throw s;
+          }
+        }
+        return;
+      case "ForOfStatement": {
+        const iterable = this.evalExpr(node.right, scope, thisVal);
+        for (const item of iterable ?? []) {
+          const loopScope = new LexicalScope(scope);
+          if (node.left.type === "VariableDeclaration") {
+            this.bindPattern(node.left.declarations[0].id, item, loopScope, node.left.kind === "const");
+          } else {
+            this.assignPattern(node.left, item, loopScope, thisVal);
+          }
+          try {
+            this.execStmt(node.body, loopScope, thisVal);
+          } catch (s) {
+            if (s instanceof BreakSignal) break;
+            if (s instanceof ContinueSignal) continue;
+            throw s;
+          }
+        }
+        return;
+      }
+      case "ForStatement": {
+        const forScope = new LexicalScope(scope);
+        if (node.init) {
+          if (node.init.type === "VariableDeclaration") this.execStmt(node.init, forScope, thisVal);
+          else this.evalExpr(node.init, forScope, thisVal);
+        }
+        while (node.test ? this.evalExpr(node.test, forScope, thisVal) : true) {
+          try {
+            this.execStmt(node.body, new LexicalScope(forScope), thisVal);
+          } catch (s) {
+            if (s instanceof BreakSignal) break;
+            if (s instanceof ContinueSignal) ; else throw s;
+          }
+          if (node.update) this.evalExpr(node.update, forScope, thisVal);
+        }
+        return;
+      }
+      case "BreakStatement":
+        throw new BreakSignal();
+      case "ContinueStatement":
+        throw new ContinueSignal();
+    }
+  }
+  // --- Expressions ---
+  evalExpr(node, scope, thisVal) {
+    switch (node.type) {
+      case "NumberLiteral":
+      case "StringLiteral":
+      case "BooleanLiteral":
+        return node.value;
+      case "NullLiteral":
+        return null;
+      case "UndefinedLiteral":
+        return void 0;
+      case "ThisExpression":
+        return thisVal;
+      case "Identifier":
+        return this.resolve(node.name, scope);
+      case "TemplateLiteral": {
+        let out = node.quasis[0] ?? "";
+        for (let i = 0; i < node.expressions.length; i++) {
+          out += String(this.evalExpr(node.expressions[i], scope, thisVal) ?? "");
+          out += node.quasis[i + 1] ?? "";
+        }
+        return out;
+      }
+      case "ArrayExpression": {
+        const arr = [];
+        for (const el of node.elements) {
+          if (el === null) arr.push(void 0);
+          else if (el.type === "SpreadElement") arr.push(...this.evalExpr(el.argument, scope, thisVal));
+          else arr.push(this.evalExpr(el, scope, thisVal));
+        }
+        return arr;
+      }
+      case "ObjectExpression":
+        return this.evalObject(node, scope, thisVal);
+      case "UnaryExpression": {
+        const arg = this.evalExpr(node.argument, scope, thisVal);
+        switch (node.operator) {
+          case "!":
+            return !arg;
+          case "-":
+            return -arg;
+          case "+":
+            return +arg;
+          case "typeof":
+            return typeof arg;
+          case "void":
+            return void 0;
+        }
+        return void 0;
+      }
+      case "UpdateExpression": {
+        const old = Number(this.evalTarget(node.argument, scope, thisVal));
+        const next = node.operator === "++" ? old + 1 : old - 1;
+        this.assign(node.argument, next, scope, thisVal);
+        return node.prefix ? next : old;
+      }
+      case "BinaryExpression":
+        return this.evalBinary(
+          node.operator,
+          this.evalExpr(node.left, scope, thisVal),
+          this.evalExpr(node.right, scope, thisVal)
+        );
+      case "LogicalExpression": {
+        const left = this.evalExpr(node.left, scope, thisVal);
+        if (node.operator === "&&") return left ? this.evalExpr(node.right, scope, thisVal) : left;
+        if (node.operator === "||") return left ? left : this.evalExpr(node.right, scope, thisVal);
+        return left ?? this.evalExpr(node.right, scope, thisVal);
+      }
+      case "ConditionalExpression":
+        return this.evalExpr(node.test, scope, thisVal) ? this.evalExpr(node.consequent, scope, thisVal) : this.evalExpr(node.alternate, scope, thisVal);
+      case "AssignmentExpression":
+        return this.evalAssignment(node, scope, thisVal);
+      case "MemberExpression": {
+        const obj = this.evalExpr(node.object, scope, thisVal);
+        if (node.optional && obj == null) return void 0;
+        const key = node.computed ? this.evalExpr(node.property, scope, thisVal) : node.property.name;
+        return memberGet(obj, key);
+      }
+      case "CallExpression":
+        return this.evalCall(node, scope, thisVal);
+      case "ArrowFunction":
+        return this.makeFunction(
+          node,
+          scope,
+          /* lexicalThis */
+          thisVal,
+          /* dynamic */
+          false
+        );
+      case "SequenceExpression": {
+        let v;
+        for (const e of node.expressions) v = this.evalExpr(e, scope, thisVal);
+        return v;
+      }
+      case "SpreadElement":
+        return this.evalExpr(node.argument, scope, thisVal);
+    }
+  }
+  evalObject(node, scope, thisVal) {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (prop.type === "SpreadElement") {
+        Object.assign(obj, this.evalExpr(prop.argument, scope, thisVal));
+        continue;
+      }
+      const p = prop;
+      const key = p.computed ? String(this.evalExpr(p.key, scope, thisVal)) : p.key.value;
+      if (p.kind === "get") {
+        const fn = this.makeFunction(p.value, scope, thisVal, true);
+        Object.defineProperty(obj, key, { get: fn, enumerable: true, configurable: true });
+      } else if (p.kind === "set") {
+        const fn = this.makeFunction(p.value, scope, thisVal, true);
+        Object.defineProperty(obj, key, { set: fn, enumerable: true, configurable: true });
+      } else if (p.kind === "method") {
+        obj[key] = this.makeFunction(p.value, scope, thisVal, true);
+      } else {
+        obj[key] = this.evalExpr(p.value, scope, thisVal);
+      }
+    }
+    return obj;
+  }
+  evalCall(node, scope, thisVal) {
+    let fn;
+    let callThis = void 0;
+    if (node.callee.type === "MemberExpression") {
+      const m = node.callee;
+      const obj = this.evalExpr(m.object, scope, thisVal);
+      if (m.optional && obj == null) return void 0;
+      callThis = obj;
+      const key = m.computed ? this.evalExpr(m.property, scope, thisVal) : m.property.name;
+      fn = memberGet(obj, key);
+    } else {
+      fn = this.evalExpr(node.callee, scope, thisVal);
+    }
+    if (node.optional && fn == null) return void 0;
+    const args = this.evalArguments(node.arguments, scope, thisVal);
+    if (typeof fn !== "function") {
+      if (fn == null) return void 0;
+      throw new TypeError(`Expression value is not a function`);
+    }
+    return fn.apply(callThis, args);
+  }
+  evalArguments(nodes, scope, thisVal) {
+    const args = [];
+    for (const a of nodes) {
+      if (a.type === "SpreadElement") args.push(...this.evalExpr(a.argument, scope, thisVal));
+      else args.push(this.evalExpr(a, scope, thisVal));
+    }
+    return args;
+  }
+  evalBinary(op, l, r) {
+    switch (op) {
+      case "+":
+        return l + r;
+      case "-":
+        return l - r;
+      case "*":
+        return l * r;
+      case "/":
+        return l / r;
+      case "%":
+        return l % r;
+      case "**":
+        return l ** r;
+      case "==":
+        return l == r;
+      case "!=":
+        return l != r;
+      case "===":
+        return l === r;
+      case "!==":
+        return l !== r;
+      case "<":
+        return l < r;
+      case ">":
+        return l > r;
+      case "<=":
+        return l <= r;
+      case ">=":
+        return l >= r;
+      case "in":
+        return l in r;
+      case "instanceof":
+        return l instanceof r;
+    }
+    return void 0;
+  }
+  evalAssignment(node, scope, thisVal) {
+    const op = node.operator;
+    if (op === "=") {
+      const value2 = this.evalExpr(node.right, scope, thisVal);
+      this.assign(node.left, value2, scope, thisVal);
+      return value2;
+    }
+    const current = this.evalTarget(node.left, scope, thisVal);
+    let value;
+    if (op === "&&=") {
+      if (!current) return current;
+      value = this.evalExpr(node.right, scope, thisVal);
+    } else if (op === "||=") {
+      if (current) return current;
+      value = this.evalExpr(node.right, scope, thisVal);
+    } else if (op === "??=") {
+      if (current != null) return current;
+      value = this.evalExpr(node.right, scope, thisVal);
+    } else {
+      const rhs = this.evalExpr(node.right, scope, thisVal);
+      value = this.evalBinary(op.slice(0, -1), current, rhs);
+    }
+    this.assign(node.left, value, scope, thisVal);
+    return value;
+  }
+  /** Read the current value of an assignment target (for compound ops). */
+  evalTarget(node, scope, thisVal) {
+    return this.evalExpr(node, scope, thisVal);
+  }
+  assign(target, value, scope, thisVal) {
+    if (target.type === "Identifier") {
+      if (!scope.set(target.name, value)) this.root.set(target.name, value);
+      return;
+    }
+    if (target.type === "MemberExpression") {
+      const obj = this.evalExpr(target.object, scope, thisVal);
+      if (obj == null) throw new TypeError("Cannot assign to a property of null or undefined");
+      const key = target.computed ? this.evalExpr(target.property, scope, thisVal) : target.property.name;
+      obj[key] = value;
+      return;
+    }
+    throw new TypeError("Invalid assignment target");
+  }
+  resolve(name, scope) {
+    if (scope.has(name)) return scope.get(name);
+    if (this.root.has(name)) return this.root.get(name);
+    if (GLOBAL_ALLOW.has(name)) return globalThis[name];
+    return void 0;
+  }
+  // --- Functions ---
+  makeFunction(node, definingScope, lexicalThis, dynamicThis) {
+    const self = this;
+    return function(...args) {
+      const fnScope = new LexicalScope(definingScope);
+      self.bindParams(node.params, args, fnScope);
+      const usedThis = dynamicThis ? this : lexicalThis;
+      if (node.expression) {
+        return self.evalExpr(node.body, fnScope, usedThis);
+      }
+      try {
+        self.execBlock(node.body.body, new LexicalScope(fnScope), usedThis);
+      } catch (signal2) {
+        if (signal2 instanceof ReturnSignal) return signal2.value;
+        throw signal2;
+      }
+      return void 0;
+    };
+  }
+  bindParams(params, args, scope) {
+    for (let i = 0; i < params.length; i++) {
+      const p = params[i];
+      if (p.type === "RestElement") {
+        this.bindPattern(p.argument, args.slice(i), scope, false);
+        break;
+      }
+      this.bindPattern(p, args[i], scope, false);
+    }
+  }
+  bindPattern(pattern, value, scope, constant) {
+    switch (pattern.type) {
+      case "Identifier":
+        scope.declare(pattern.name, value, constant);
+        return;
+      case "AssignmentPattern":
+        this.bindPattern(pattern.left, value === void 0 ? this.evalExpr(pattern.right, scope, void 0) : value, scope, constant);
+        return;
+      case "RestElement":
+        this.bindPattern(pattern.argument, value, scope, constant);
+        return;
+      case "ObjectPattern": {
+        const obj = value ?? {};
+        const used = /* @__PURE__ */ new Set();
+        for (const prop of pattern.properties) {
+          const key = prop.computed ? String(this.evalExpr(prop.key, scope, void 0)) : prop.key.value;
+          used.add(key);
+          this.bindPattern(prop.value, obj[key], scope, constant);
+        }
+        if (pattern.rest) {
+          const rest = {};
+          for (const k of Object.keys(obj)) if (!used.has(k)) rest[k] = obj[k];
+          scope.declare(pattern.rest.name, rest, constant);
+        }
+        return;
+      }
+      case "ArrayPattern": {
+        const arr = value ?? [];
+        for (let i = 0; i < pattern.elements.length; i++) {
+          const el = pattern.elements[i];
+          if (el) this.bindPattern(el, arr[i], scope, constant);
+        }
+        if (pattern.rest) this.bindPattern(pattern.rest, arr.slice(pattern.elements.length), scope, constant);
+        return;
+      }
+    }
+  }
+  /** Assign into an existing pattern target (for-of without declaration). */
+  assignPattern(pattern, value, scope, thisVal) {
+    if (pattern.type === "Identifier") {
+      if (!scope.set(pattern.name, value)) this.root.set(pattern.name, value);
+      return;
+    }
+    this.bindPattern(pattern, value, scope, false);
+  }
+};
+
+// src/evaluator/index.ts
+function evaluateExpression(source, root, thisVal) {
+  const program = parse(source, "expression");
+  return new Interpreter(root).run(program, thisVal);
+}
+function evaluateAction(source, root, thisVal) {
+  const program = parse(source, "program");
+  return new Interpreter(root).run(program, thisVal);
+}
+
+// src/errors.ts
+var DOCS = "https://velofy.github.io/summit";
+function distance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (!m) return n;
+  if (!n) return m;
+  let prev = Array.from({ length: n + 1 }, (_, j) => j);
+  for (let i = 1; i <= m; i++) {
+    const curr = [i];
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    prev = curr;
+  }
+  return prev[n];
+}
+function suggest(name, candidates) {
+  let best = null;
+  let bestD = Infinity;
+  for (const c of candidates) {
+    const d = distance(name, c);
+    if (d < bestD) {
+      bestD = d;
+      best = c;
+    }
+  }
+  const limit = name.length <= 4 ? 1 : 2;
+  return best !== null && bestD <= limit ? best : null;
+}
+function describeEl(el) {
+  const tag = el.tagName.toLowerCase();
+  const id2 = el.id ? `#${el.id}` : "";
+  const cls = el.classList.length ? "." + Array.from(el.classList).slice(0, 2).join(".") : "";
+  return `<${tag}${id2}${cls}>`;
+}
+function build(code, message, ctx) {
+  const lines = [`[summit] ${code}: ${message}`];
+  if (ctx.hint) lines.push(`  ${ctx.hint}`);
+  if (ctx.expression) lines.push(`  expression: ${ctx.expression.trim()}`);
+  if (ctx.el) lines.push(`  element: ${describeEl(ctx.el)}`);
+  lines.push(`  docs: ${DOCS}/${ctx.doc ? ctx.doc + "/" : ""}`);
+  return lines.join("\n");
+}
+function warn(code, message, ctx = {}) {
+  if (ctx.cause !== void 0) console.warn(build(code, message, ctx), "\n ", ctx.cause);
+  else console.warn(build(code, message, ctx));
+}
+function fail(code, message, ctx = {}) {
+  if (ctx.cause !== void 0) console.error(build(code, message, ctx), "\n ", ctx.cause);
+  else console.error(build(code, message, ctx));
+}
+var seen = /* @__PURE__ */ new Set();
+function warnOnce(key, code, message, ctx = {}) {
+  if (seen.has(key)) return;
+  seen.add(key);
+  warn(code, message, ctx);
+}
+
+// src/dom.ts
+var metaMap = /* @__PURE__ */ new WeakMap();
+function meta(node) {
+  let m = metaMap.get(node);
+  if (!m) metaMap.set(node, m = {});
+  return m;
+}
+var markerCount = 0;
+function nextMarker() {
+  return ++markerCount;
+}
+function addCleanup(el, fn) {
+  const m = meta(el);
+  (m.cleanups ?? (m.cleanups = [])).push(fn);
+}
+function runCleanups(el) {
+  const m = metaMap.get(el);
+  if (!m) return;
+  if (m.cleanups) {
+    for (const fn of m.cleanups) {
+      try {
+        fn();
+      } catch (err) {
+        fail("E601", "a cleanup callback threw during teardown.", { doc: "lifecycle", cause: err });
+      }
+    }
+    m.cleanups = [];
+  }
+  if (m.destroyCallbacks) {
+    for (const fn of m.destroyCallbacks) {
+      try {
+        fn();
+      } catch (err) {
+        fail("E602", "a destroy() callback threw during teardown.", { doc: "lifecycle", cause: err });
+      }
+    }
+    m.destroyCallbacks = [];
+  }
+}
+function resolveScopes(el) {
+  const own = metaMap.get(el)?.scopes;
+  if (own) return own;
+  let parent = el.parentElement;
+  while (parent) {
+    const s = metaMap.get(parent)?.scopes;
+    if (s) return s;
+    parent = parent.parentElement;
+  }
+  return [];
+}
+function closestRoot(el) {
+  let cur = el;
+  while (cur) {
+    if (metaMap.get(cur)?.isRoot) return cur;
+    cur = cur.parentElement;
+  }
+  return null;
+}
+function refsFor(el) {
+  const root = closestRoot(el) ?? el;
+  const m = meta(root);
+  return m.refs ?? (m.refs = {});
+}
+
+// src/scope/environment.ts
+var DOLLAR = 36;
+function makeEnv(el, locals) {
+  const scopes = resolveScopes(el);
+  const thisVal = scopes.length ? scopes[scopes.length - 1] : void 0;
+  const ctx = {
+    el,
+    scopes,
+    evaluate: (expression) => evaluateExpression(expression, env, thisVal),
+    effect: (fn) => {
+      const dispose = domEffect(fn);
+      addCleanup(el, dispose);
+    },
+    cleanup: (fn) => addCleanup(el, fn)
+  };
+  const env = {
+    has(name) {
+      if (locals && name in locals) return true;
+      for (let i = scopes.length - 1; i >= 0; i--) {
+        if (name in scopes[i]) return true;
+      }
+      if (name.charCodeAt(0) === DOLLAR && getMagic(name.slice(1))) return true;
+      return false;
+    },
+    get(name) {
+      if (locals && name in locals) return locals[name];
+      for (let i = scopes.length - 1; i >= 0; i--) {
+        if (name in scopes[i]) return scopes[i][name];
+      }
+      if (name.charCodeAt(0) === DOLLAR) {
+        const factory = getMagic(name.slice(1));
+        if (factory) return factory(ctx);
+      }
+      return void 0;
+    },
+    set(name, value) {
+      for (let i = scopes.length - 1; i >= 0; i--) {
+        if (name in scopes[i]) {
+          scopes[i][name] = value;
+          return;
+        }
+      }
+      if (scopes.length) scopes[scopes.length - 1][name] = value;
+    }
+  };
+  return {
+    env,
+    thisVal,
+    evaluate: (expression) => evaluateExpression(expression, env, thisVal),
+    evaluateAction: (expression, extraLocals) => {
+      if (!extraLocals) return evaluateAction(expression, env, thisVal);
+      const layered = {
+        has: (n) => n in extraLocals ? true : env.has(n),
+        get: (n) => n in extraLocals ? extraLocals[n] : env.get(n),
+        set: (n, v) => env.set(n, v)
+      };
+      return evaluateAction(expression, layered, thisVal);
+    }
+  };
+}
+function attachMagics(rawTarget, el, scopes) {
+  const ctx = {
+    el,
+    scopes,
+    evaluate: (expression) => evaluateExpression(expression, makeEnv(el).env, scopes.length ? scopes[scopes.length - 1] : void 0),
+    effect: (fn) => addCleanup(el, domEffect(fn)),
+    cleanup: (fn) => addCleanup(el, fn)
+  };
+  for (const name of magicNames()) {
+    Object.defineProperty(rawTarget, "$" + name, {
+      get: () => getMagic(name)(ctx),
+      enumerable: false,
+      configurable: true
+    });
+  }
+}
+
+// src/lifecycle/attributes.ts
+function parseAttribute(rawName, expression) {
+  let name = rawName;
+  if (name[0] === "@") name = "on:" + name.slice(1);
+  else if (name[0] === ":") name = "bind:" + name.slice(1);
+  else if (name.startsWith("s-")) name = name.slice(2);
+  else return null;
+  const parts = name.split(".");
+  const head = parts[0];
+  const modifiers = parts.slice(1);
+  const colon = head.indexOf(":");
+  let dirName;
+  let value;
+  if (colon === -1) {
+    dirName = head;
+    value = null;
+  } else {
+    dirName = head.slice(0, colon);
+    value = head.slice(colon + 1);
+  }
+  return { name: dirName, value, modifiers, expression, raw: rawName };
+}
+
+// src/magics/persist.ts
+var MARK = "__summitPersist";
+function createPersist(initial) {
+  return {
+    [MARK]: true,
+    initial,
+    key: null,
+    as(key) {
+      this.key = String(key);
+      return this;
+    }
+  };
+}
+function isPersistMarker(value) {
+  return !!value && typeof value === "object" && value[MARK] === true;
+}
+
+// src/lifecycle/tree.ts
+var STRUCTURAL = /* @__PURE__ */ new Set(["if", "for", "teleport"]);
+var SPECIAL = /* @__PURE__ */ new Set(["data", "ignore"]);
+var summitGlobal;
+function setSummitGlobal(g) {
+  summitGlobal = g;
+}
+function collectDirectives(el) {
+  const out = [];
+  for (const attr of Array.from(el.attributes)) {
+    const parsed = parseAttribute(attr.name, attr.value);
+    if (!parsed) continue;
+    if (SPECIAL.has(parsed.name) || getDirective(parsed.name)) {
+      out.push(parsed);
+    } else {
+      const hit = suggest(parsed.name, [...directiveNames(), ...SPECIAL]);
+      warnOnce(
+        `dir:${parsed.name}`,
+        "E201",
+        `unknown directive "${attr.name}".`,
+        {
+          el,
+          doc: hit ? `s-${hit}` : "start",
+          hint: hit ? `Did you mean "s-${hit}"?` : "See the directive reference."
+        }
+      );
+    }
+  }
+  return out;
+}
+function priorityOf(name) {
+  return getDirective(name)?.priority ?? DEFAULT_PRIORITY;
+}
+function makeUtils(el, scopes) {
+  const handle = makeEnv(el);
+  return {
+    evaluate: (expression) => handle.evaluate(expression),
+    evaluateAction: (expression, locals) => handle.evaluateAction(expression, locals),
+    effect: (fn) => {
+      const dispose = domEffect(fn);
+      addCleanup(el, dispose);
+    },
+    cleanup: (fn) => addCleanup(el, fn),
+    initTree,
+    destroyTree,
+    scopes,
+    makeEnv: (e, locals) => makeEnv(e, locals).env,
+    Summit: summitGlobal
+  };
+}
+function runDirective(el, dmeta, scopes) {
+  const entry = getDirective(dmeta.name);
+  if (!entry) return;
+  try {
+    entry.handler(el, dmeta, makeUtils(el, scopes));
+  } catch (err) {
+    fail("E301", `s-${dmeta.name} failed while evaluating its expression.`, {
+      el,
+      expression: dmeta.expression,
+      doc: `s-${dmeta.name}`,
+      hint: "Every name in the expression must be state from an enclosing s-data, or an allowed global.",
+      cause: err
+    });
+  }
+}
+var DATA_PROVIDER_RE = /^([A-Za-z_$][\w$]*)\s*(\(([\s\S]*)\))?$/;
+function resolvePersist(scope, el) {
+  const hasLS = typeof localStorage !== "undefined";
+  for (const key of Object.keys(scope)) {
+    const marker = scope[key];
+    if (!isPersistMarker(marker)) continue;
+    const storeKey = marker.key ?? key;
+    let value = marker.initial;
+    if (hasLS) {
+      try {
+        const stored = localStorage.getItem(storeKey);
+        if (stored != null) value = JSON.parse(stored);
+      } catch {
+      }
+    }
+    scope[key] = value;
+    if (hasLS) {
+      const dispose = domEffect(() => {
+        try {
+          localStorage.setItem(storeKey, JSON.stringify(scope[key]));
+        } catch {
+        }
+      });
+      addCleanup(el, dispose);
+    }
+  }
+}
+function initData(el, dmeta, parentScopes) {
+  const parentEnv = makeEnv(el);
+  const expr = dmeta.expression.trim();
+  let raw;
+  const match = expr.match(DATA_PROVIDER_RE);
+  if (match && getData(match[1])) {
+    const provider = getData(match[1]);
+    const args = match[2] ? parentEnv.evaluate("[" + (match[3] ?? "") + "]") : [];
+    raw = provider(...args);
+  } else if (expr === "") {
+    raw = {};
+  } else {
+    raw = parentEnv.evaluate("(" + expr + ")");
+  }
+  if (raw === null || typeof raw !== "object") raw = {};
+  const scope = createScope(raw);
+  resolvePersist(scope, el);
+  const newScopes = [...parentScopes, scope];
+  const m = meta(el);
+  m.scopes = newScopes;
+  m.isRoot = true;
+  m.refs = {};
+  attachMagics(raw, el, newScopes);
+  const initFn = scope["init"];
+  if (typeof initFn === "function") {
+    try {
+      initFn();
+    } catch (err) {
+      fail("E101", "s-data init() threw.", { el, doc: "s-data", cause: err });
+    }
+  }
+  const destroyFn = scope["destroy"];
+  if (typeof destroyFn === "function") {
+    addCleanup(el, () => {
+      try {
+        destroyFn();
+      } catch (err) {
+        fail("E102", "s-data destroy() threw.", { el, doc: "s-data", cause: err });
+      }
+    });
+  }
+  return newScopes;
+}
+function initTree(el, scopesArg) {
+  const m = meta(el);
+  if (m.initialized || m.ignore) return;
+  if (el.hasAttribute("s-ignore")) {
+    m.ignore = true;
+    m.initialized = true;
+    return;
+  }
+  let scopes = scopesArg ?? resolveScopes(el);
+  m.scopes = scopes;
+  m.marker = nextMarker();
+  const dirs = collectDirectives(el);
+  const dataDir = dirs.find((d) => d.name === "data");
+  if (dataDir) scopes = initData(el, dataDir, scopes);
+  const structural = dirs.find((d) => STRUCTURAL.has(d.name));
+  if (structural) {
+    m.initialized = true;
+    runDirective(el, structural, scopes);
+    return;
+  }
+  const rest = dirs.filter((d) => d.name !== "data").sort((a, b) => priorityOf(a.name) - priorityOf(b.name));
+  for (const d of rest) runDirective(el, d, scopes);
+  m.initialized = true;
+  for (const child of Array.from(el.children)) {
+    initTree(child, scopes);
+  }
+}
+function destroyTree(el) {
+  runCleanups(el);
+  for (const child of Array.from(el.children)) {
+    destroyTree(child);
+  }
+  meta(el).initialized = false;
+}
+
+// src/lifecycle/observer.ts
+var observer = null;
+function startObserver(root) {
+  if (observer) return;
+  observer = new MutationObserver(handleMutations);
+  observer.observe(root, { childList: true, subtree: true });
+}
+function handleMutations(records) {
+  const removed = [];
+  const added = [];
+  for (const rec of records) {
+    if (rec.type !== "childList") continue;
+    rec.removedNodes.forEach((n) => {
+      if (n.nodeType === 1) removed.push(n);
+    });
+    rec.addedNodes.forEach((n) => {
+      if (n.nodeType === 1) added.push(n);
+    });
+  }
+  for (const el of removed) {
+    if (!el.isConnected) destroyTree(el);
+  }
+  for (const el of added) {
+    if (el.isConnected && !meta(el).initialized) initTree(el);
+  }
+}
+
+// src/directives/text.ts
+function toDisplay(value) {
+  return value == null ? "" : String(value);
+}
+var text = (el, meta2, utils) => {
+  utils.effect(() => {
+    el.textContent = toDisplay(utils.evaluate(meta2.expression));
+  });
+};
+var html = (el, meta2, utils) => {
+  utils.effect(() => {
+    el.innerHTML = toDisplay(utils.evaluate(meta2.expression));
+    let child = el.firstElementChild;
+    while (child) {
+      utils.initTree(child, utils.scopes);
+      child = child.nextElementSibling;
+    }
+  });
+};
+
+// src/directives/shared.ts
+var BOOLEAN_ATTRS = /* @__PURE__ */ new Set([
+  "disabled",
+  "checked",
+  "required",
+  "readonly",
+  "hidden",
+  "selected",
+  "open",
+  "multiple",
+  "autofocus",
+  "novalidate",
+  "autoplay",
+  "controls",
+  "loop",
+  "muted",
+  "playsinline",
+  "default",
+  "ismap",
+  "reversed",
+  "async",
+  "defer",
+  "inert"
+]);
+var PROP_ATTRS = /* @__PURE__ */ new Set(["value", "checked", "selected", "indeterminate", "muted", "volume"]);
+function camelCase(input) {
+  return input.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function kebabCase(input) {
+  return input.replace(/[A-Z]/g, (c) => "-" + c.toLowerCase());
+}
+function classTokens(value) {
+  if (!value) return [];
+  if (typeof value === "string") return value.split(/\s+/).filter(Boolean);
+  if (Array.isArray(value)) return value.flatMap((v) => classTokens(v));
+  if (typeof value === "object") {
+    return Object.entries(value).filter(([, on2]) => on2).map(([cls]) => cls);
+  }
+  return [];
+}
+function mergeClass(base, value) {
+  const set = /* @__PURE__ */ new Set();
+  for (const t of base.split(/\s+/)) if (t) set.add(t);
+  for (const t of classTokens(value)) set.add(t);
+  return [...set].join(" ");
+}
+function mergeStyle(base, value) {
+  const parts = [];
+  if (base) parts.push(base.trim().replace(/;?\s*$/, ""));
+  if (typeof value === "string") {
+    parts.push(value.trim().replace(/;?\s*$/, ""));
+  } else if (value && typeof value === "object") {
+    for (const [prop, val] of Object.entries(value)) {
+      if (val == null || val === false) continue;
+      parts.push(`${kebabCase(prop)}: ${String(val)}`);
+    }
+  }
+  return parts.filter(Boolean).join("; ");
+}
+function applyAttribute(el, name, value) {
+  if (BOOLEAN_ATTRS.has(name)) {
+    if (value) el.setAttribute(name, "");
+    else el.removeAttribute(name);
+    if (name in el) el[name] = !!value;
+    return;
+  }
+  if (PROP_ATTRS.has(name) && name in el) {
+    el[name] = value;
+    return;
+  }
+  if (value === false || value == null) {
+    el.removeAttribute(name);
+  } else {
+    el.setAttribute(name, String(value));
+  }
+}
+
+// src/directives/bind.ts
+var bind = (el, meta2, utils) => {
+  if (meta2.value === null) {
+    applyBindObject(el, meta2.expression, utils);
+    return;
+  }
+  const name = meta2.modifiers.includes("camel") ? camelCase(meta2.value) : meta2.value;
+  if (name === "class") {
+    const base = el.getAttribute("class") ?? "";
+    utils.effect(() => {
+      el.setAttribute("class", mergeClass(base, utils.evaluate(meta2.expression)));
+    });
+    return;
+  }
+  if (name === "style") {
+    const base = el.getAttribute("style") ?? "";
+    utils.effect(() => {
+      const merged = mergeStyle(base, utils.evaluate(meta2.expression));
+      if (merged) el.setAttribute("style", merged);
+      else el.removeAttribute("style");
+    });
+    return;
+  }
+  utils.effect(() => {
+    applyAttribute(el, name, utils.evaluate(meta2.expression));
+  });
+};
+function applyBindObject(el, expression, utils) {
+  const obj = utils.evaluate(expression);
+  if (!obj || typeof obj !== "object") return;
+  for (const [key, raw] of Object.entries(obj)) {
+    if (key[0] === "@") {
+      const event = key.slice(1);
+      const handler = raw;
+      el.addEventListener(event, handler);
+      utils.cleanup(() => el.removeEventListener(event, handler));
+    } else if (key[0] === ":") {
+      const attr = key.slice(1);
+      const getter = raw;
+      utils.effect(() => applyAttribute(el, attr, typeof getter === "function" ? getter() : getter));
+    } else {
+      applyAttribute(el, key, raw);
+    }
+  }
+}
+
+// src/directives/on.ts
+var SYSTEM = /* @__PURE__ */ new Set(["shift", "ctrl", "alt", "cmd", "meta"]);
+var BEHAVIOR = /* @__PURE__ */ new Set([
+  "prevent",
+  "stop",
+  "self",
+  "outside",
+  "once",
+  "capture",
+  "passive",
+  "window",
+  "document",
+  "camel",
+  "dot",
+  "debounce",
+  "throttle"
+]);
+var KEY_ALIASES = {
+  enter: "Enter",
+  tab: "Tab",
+  space: " ",
+  esc: "Escape",
+  escape: "Escape",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  "arrow-up": "ArrowUp",
+  "arrow-down": "ArrowDown",
+  "arrow-left": "ArrowLeft",
+  "arrow-right": "ArrowRight",
+  "page-up": "PageUp",
+  "page-down": "PageDown",
+  home: "Home",
+  end: "End",
+  delete: "Delete",
+  backspace: "Backspace"
+};
+function isDuration(m) {
+  return /^\d+(ms|s)?$/.test(m);
+}
+function parseDuration(m) {
+  if (m.endsWith("ms")) return parseInt(m, 10);
+  if (m.endsWith("s")) return parseInt(m, 10) * 1e3;
+  return parseInt(m, 10);
+}
+function durationFor(mods, name) {
+  const i = mods.indexOf(name);
+  if (i === -1) return null;
+  const next = mods[i + 1];
+  return next && isDuration(next) ? parseDuration(next) : 250;
+}
+function matchKey(e, mod) {
+  const key = e.key;
+  if (!key) return false;
+  const alias = KEY_ALIASES[mod];
+  if (alias) return key === alias;
+  return kebabCase(key).toLowerCase() === mod.toLowerCase() || key.toLowerCase() === mod.toLowerCase();
+}
+function passesSystem(e, mods) {
+  const k = e;
+  if (mods.includes("shift") && !k.shiftKey) return false;
+  if (mods.includes("ctrl") && !k.ctrlKey) return false;
+  if (mods.includes("alt") && !k.altKey) return false;
+  if ((mods.includes("cmd") || mods.includes("meta")) && !k.metaKey) return false;
+  return true;
+}
+function debounce(fn, ms) {
+  let t;
+  return (e) => {
+    clearTimeout(t);
+    t = setTimeout(() => fn(e), ms);
+  };
+}
+function throttle(fn, ms) {
+  let last = 0;
+  let scheduled;
+  return (e) => {
+    const now = Date.now();
+    const remaining = ms - (now - last);
+    if (remaining <= 0) {
+      last = now;
+      fn(e);
+    } else if (!scheduled) {
+      scheduled = setTimeout(() => {
+        last = Date.now();
+        scheduled = void 0;
+        fn(e);
+      }, remaining);
+    }
+  };
+}
+var on = (el, meta2, utils) => {
+  const mods = meta2.modifiers;
+  let event = meta2.value ?? "";
+  if (mods.includes("camel")) event = camelCase(event);
+  if (mods.includes("dot")) event = event.replace(/-/g, ".");
+  const keyMods = mods.filter((m) => !SYSTEM.has(m) && !BEHAVIOR.has(m) && !isDuration(m));
+  const target = mods.includes("window") ? window : mods.includes("document") || mods.includes("outside") ? document : el;
+  const options = {};
+  if (mods.includes("capture")) options.capture = true;
+  if (mods.includes("passive")) options.passive = true;
+  if (mods.includes("once")) options.once = true;
+  const invoke = (e) => {
+    if (mods.includes("self") && e.target !== el) return;
+    if (mods.includes("outside")) {
+      const t = e.target;
+      if (el === t || el.contains(t)) return;
+      if (!document.documentElement.contains(t)) return;
+    }
+    if (keyMods.length && !keyMods.some((k) => matchKey(e, k))) return;
+    if (!passesSystem(e, mods)) return;
+    if (mods.includes("prevent")) e.preventDefault();
+    if (mods.includes("stop")) e.stopPropagation();
+    try {
+      const result = utils.evaluateAction(meta2.expression, { $event: e });
+      if (typeof result === "function") result(e);
+    } catch (err) {
+      fail("E301", `@${event} handler failed while evaluating its expression.`, {
+        el,
+        expression: meta2.expression,
+        doc: "s-on",
+        hint: "Names must be state from an enclosing s-data, a $magic, or an allowed global.",
+        cause: err
+      });
+    }
+  };
+  const debounceMs = durationFor(mods, "debounce");
+  const throttleMs = durationFor(mods, "throttle");
+  let handler = invoke;
+  if (debounceMs != null) handler = debounce(invoke, debounceMs);
+  else if (throttleMs != null) handler = throttle(invoke, throttleMs);
+  target.addEventListener(event, handler, options);
+  utils.cleanup(() => target.removeEventListener(event, handler, options));
+};
+
+// src/directives/model.ts
+function coerce(value, mods) {
+  if (mods.includes("number")) {
+    const n = parseFloat(value);
+    return isNaN(n) ? value : n;
+  }
+  if (mods.includes("boolean")) {
+    if (value === "true") return true;
+    if (value === "false") return false;
+    return Boolean(value);
+  }
+  return value;
+}
+function debounce2(fn, ms) {
+  let t;
+  return () => {
+    clearTimeout(t);
+    t = setTimeout(fn, ms);
+  };
+}
+function durationFor2(mods, name) {
+  const i = mods.indexOf(name);
+  if (i === -1) return null;
+  const next = mods[i + 1];
+  if (next && /^\d+(ms|s)?$/.test(next)) {
+    return next.endsWith("s") && !next.endsWith("ms") ? parseInt(next, 10) * 1e3 : parseInt(next, 10);
+  }
+  return 250;
+}
+var model = (el, meta2, utils) => {
+  const input = el;
+  const select = el;
+  const mods = meta2.modifiers;
+  const expr = meta2.expression;
+  const type = input.type;
+  const tag = el.tagName;
+  const getValue = () => utils.evaluate(expr);
+  const setValue = (v) => {
+    utils.evaluateAction(expr + " = $model", { $model: v });
+  };
+  if (mods.includes("fill")) {
+    const current = getValue();
+    if (current === void 0 || current === null || current === "") {
+      setValue(coerce(input.value ?? input.getAttribute("value") ?? "", mods));
+    }
+  }
+  const readFromElement = () => {
+    if (type === "checkbox") {
+      const current = getValue();
+      if (Array.isArray(current)) {
+        const next = new Set(current);
+        if (input.checked) next.add(input.value);
+        else next.delete(input.value);
+        return [...next];
+      }
+      return input.checked;
+    }
+    if (type === "radio") {
+      return coerce(input.value, mods);
+    }
+    if (tag === "SELECT" && select.multiple) {
+      return Array.from(select.selectedOptions).map((o) => o.value);
+    }
+    return coerce(input.value, mods);
+  };
+  const writeToElement = (value) => {
+    if (type === "checkbox") {
+      input.checked = Array.isArray(value) ? value.map(String).includes(input.value) : !!value;
+      return;
+    }
+    if (type === "radio") {
+      input.checked = String(value) === input.value;
+      return;
+    }
+    if (tag === "SELECT" && select.multiple) {
+      const set = new Set(value?.map(String) ?? []);
+      for (const opt of Array.from(select.options)) opt.selected = set.has(opt.value);
+      return;
+    }
+    const str = value == null ? "" : String(value);
+    if (input.value !== str) input.value = str;
+  };
+  utils.effect(() => writeToElement(getValue()));
+  let eventName = "input";
+  if (tag === "SELECT" || type === "checkbox" || type === "radio") eventName = "change";
+  if (mods.includes("lazy") || mods.includes("change")) eventName = "change";
+  if (mods.includes("blur")) eventName = "blur";
+  let onEvent = () => setValue(readFromElement());
+  const debounceMs = durationFor2(mods, "debounce");
+  if (debounceMs != null) onEvent = debounce2(onEvent, debounceMs);
+  el.addEventListener(eventName, onEvent);
+  utils.cleanup(() => el.removeEventListener(eventName, onEvent));
+  el._summitModel = {
+    get: getValue,
+    set: setValue
+  };
+};
+
+// src/directives/transition.ts
+var configs = /* @__PURE__ */ new WeakMap();
+function config(el) {
+  let c = configs.get(el);
+  if (!c) configs.set(el, c = { classMode: false });
+  return c;
+}
+function hasTransition(el) {
+  return configs.has(el);
+}
+function tokens(list) {
+  return list ? list.split(/\s+/).filter(Boolean) : [];
+}
+function durationMod(mods, name) {
+  const i = mods.indexOf(name);
+  if (i === -1) return void 0;
+  const next = mods[i + 1];
+  if (!next) return void 0;
+  if (next.endsWith("ms")) return parseInt(next, 10);
+  if (next.endsWith("s")) return parseInt(next, 10) * 1e3;
+  return parseInt(next, 10);
+}
+var transition = (el, meta2) => {
+  const c = config(el);
+  const mods = meta2.modifiers;
+  if (meta2.value) {
+    c.classMode = true;
+    const key = meta2.value;
+    const map = {
+      enter: "enter",
+      "enter-start": "enterStart",
+      "enter-end": "enterEnd",
+      leave: "leave",
+      "leave-start": "leaveStart",
+      "leave-end": "leaveEnd"
+    };
+    c[map[key]] = meta2.expression;
+    return;
+  }
+  c.duration = durationMod(mods, "duration") ?? c.duration;
+  c.delay = durationMod(mods, "delay") ?? c.delay;
+  if (mods.includes("opacity")) c.opacity = true;
+  if (mods.includes("scale")) {
+    const i = mods.indexOf("scale");
+    const next = mods[i + 1];
+    c.scale = next && /^\d+$/.test(next) ? parseInt(next, 10) / 100 : 0.95;
+  }
+  if (!mods.includes("opacity") && c.scale === void 0) {
+    c.opacity = true;
+    c.scale = 0.95;
+  }
+};
+function afterDuration(el, fallback, done) {
+  const computed2 = getComputedStyle(el).transitionDuration;
+  const ms = computed2 && computed2 !== "0s" ? parseFloat(computed2) * 1e3 : fallback;
+  if (ms <= 0) {
+    requestAnimationFrame(() => done());
+  } else {
+    setTimeout(done, ms);
+  }
+}
+function transitionIn(el, done) {
+  const c = configs.get(el);
+  if (!c) {
+    return;
+  }
+  if (c.classMode) {
+    el.classList.add(...tokens(c.enter), ...tokens(c.enterStart));
+    requestAnimationFrame(() => {
+      el.classList.remove(...tokens(c.enterStart));
+      el.classList.add(...tokens(c.enterEnd));
+      afterDuration(el, c.duration ?? 150, () => {
+        el.classList.remove(...tokens(c.enter), ...tokens(c.enterEnd));
+      });
+    });
+    return;
+  }
+  const dur = c.duration ?? 150;
+  el.style.transition = "none";
+  if (c.opacity) el.style.opacity = "0";
+  if (c.scale !== void 0) el.style.transform = `scale(${c.scale})`;
+  requestAnimationFrame(() => {
+    el.style.transition = `all ${dur}ms ease-out ${c.delay ?? 0}ms`;
+    if (c.opacity) el.style.opacity = "1";
+    if (c.scale !== void 0) el.style.transform = "scale(1)";
+    setTimeout(() => {
+      el.style.removeProperty("transition");
+      el.style.removeProperty("opacity");
+      el.style.removeProperty("transform");
+    }, dur + (c.delay ?? 0));
+  });
+}
+function transitionOut(el, done) {
+  const c = configs.get(el);
+  if (!c) {
+    done();
+    return;
+  }
+  if (c.classMode) {
+    el.classList.add(...tokens(c.leave), ...tokens(c.leaveStart));
+    requestAnimationFrame(() => {
+      el.classList.remove(...tokens(c.leaveStart));
+      el.classList.add(...tokens(c.leaveEnd));
+      afterDuration(el, c.duration ?? 150, () => {
+        el.classList.remove(...tokens(c.leave), ...tokens(c.leaveEnd));
+        done();
+      });
+    });
+    return;
+  }
+  const dur = c.duration ?? 150;
+  el.style.transition = `all ${dur}ms ease-in ${c.delay ?? 0}ms`;
+  requestAnimationFrame(() => {
+    if (c.opacity) el.style.opacity = "0";
+    if (c.scale !== void 0) el.style.transform = `scale(${c.scale})`;
+    setTimeout(() => {
+      el.style.removeProperty("transition");
+      el.style.removeProperty("opacity");
+      el.style.removeProperty("transform");
+      done();
+    }, dur + (c.delay ?? 0));
+  });
+}
+
+// src/directives/show.ts
+var show = (el, meta2, utils) => {
+  const element = el;
+  const important = meta2.modifiers.includes("important");
+  const originalDisplay = element.style.display === "none" ? "" : element.style.display;
+  const reveal = () => {
+    if (originalDisplay) element.style.display = originalDisplay;
+    else element.style.removeProperty("display");
+  };
+  const conceal = () => {
+    if (important) element.style.setProperty("display", "none", "important");
+    else element.style.setProperty("display", "none");
+  };
+  let first = true;
+  utils.effect(() => {
+    const visible2 = !!utils.evaluate(meta2.expression);
+    const animate = hasTransition(el) && !first;
+    first = false;
+    if (!animate) {
+      if (visible2) reveal();
+      else conceal();
+      return;
+    }
+    if (visible2) {
+      reveal();
+      transitionIn(element);
+    } else {
+      transitionOut(element, conceal);
+    }
+  });
+};
+
+// src/directives/conditionals.ts
+var sIf = (el, meta2, utils) => {
+  const parent = el.parentNode;
+  if (!parent) return;
+  const anchor2 = document.createComment("s-if");
+  parent.insertBefore(anchor2, el);
+  let blueprints;
+  if (el.tagName === "TEMPLATE") {
+    blueprints = Array.from(el.content.children).map(
+      (child) => child.cloneNode(true)
+    );
+  } else {
+    const clone = el.cloneNode(true);
+    clone.removeAttribute(meta2.raw);
+    blueprints = [clone];
+  }
+  el.remove();
+  if (!blueprints.length) return;
+  const scopes = utils.scopes;
+  let current = [];
+  const remove = () => {
+    for (const node of current) {
+      utils.destroyTree(node);
+      node.remove();
+    }
+    current = [];
+  };
+  utils.effect(() => {
+    const condition = !!utils.evaluate(meta2.expression);
+    if (condition && !current.length) {
+      const nodes = blueprints.map((b) => b.cloneNode(true));
+      const frag = document.createDocumentFragment();
+      for (const node of nodes) frag.appendChild(node);
+      anchor2.parentNode?.insertBefore(frag, anchor2.nextSibling);
+      for (const node of nodes) utils.initTree(node, scopes);
+      current = nodes;
+    } else if (!condition && current.length) {
+      remove();
+    }
+  });
+  utils.cleanup(remove);
+};
+
+// src/directives/for.ts
+var FOR_RE = /^\s*(.+?)\s+(?:in|of)\s+([\s\S]+)$/;
+function parseIterator(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("(")) {
+    const inner = trimmed.slice(1, -1);
+    const parts = inner.split(",").map((s) => s.trim());
+    return { item: parts[0], index: parts[1] ?? null };
+  }
+  return { item: trimmed, index: null };
+}
+function normalize(source) {
+  if (typeof source === "number") {
+    return Array.from({ length: source }, (_, i) => ({ value: i + 1, index: i }));
+  }
+  if (Array.isArray(source)) {
+    return source.map((value, index) => ({ value, index }));
+  }
+  if (source && typeof source === "object") {
+    return Object.entries(source).map(([k, value], index) => ({
+      value,
+      index,
+      objectKey: k
+    }));
+  }
+  return [];
+}
+var sFor = (el, meta2, utils) => {
+  if (el.tagName !== "TEMPLATE") {
+    warn("E401", "s-for must be used on a <template> element.", {
+      el,
+      doc: "s-for",
+      hint: `Wrap the repeated markup: <template s-for="${meta2.expression}"><li>...</li></template>`
+    });
+    return;
+  }
+  const parent = el.parentNode;
+  if (!parent) return;
+  const blueprint = el.content.firstElementChild;
+  if (!blueprint) {
+    warn("E402", "s-for <template> needs exactly one root element.", { el, doc: "s-for" });
+    return;
+  }
+  const { item: itemName, index: indexName } = parseIterator(meta2.expression.replace(FOR_RE, "$1"));
+  const sourceExpr = meta2.expression.replace(FOR_RE, "$2");
+  const keyExpr = el.getAttribute(":key") ?? el.getAttribute("s-bind:key");
+  const anchor2 = document.createComment("s-for");
+  parent.insertBefore(anchor2, el);
+  el.remove();
+  const parentScopes = utils.scopes;
+  let blocks = /* @__PURE__ */ new Map();
+  const keyFor = (it, block) => {
+    if (!keyExpr) return it.objectKey ?? it.index;
+    const env = makeEnv(el, block).env;
+    try {
+      return evaluateExpression(keyExpr, env);
+    } catch {
+      return it.index;
+    }
+  };
+  const makeBlockScope = (it) => {
+    const data = { [itemName]: it.value };
+    if (indexName) data[indexName] = it.objectKey ?? it.index;
+    return reactive(data);
+  };
+  const clear = () => {
+    for (const block of blocks.values()) {
+      utils.destroyTree(block.node);
+      block.node.remove();
+    }
+    blocks.clear();
+  };
+  utils.effect(() => {
+    const items = normalize(utils.evaluate(sourceExpr));
+    const next = /* @__PURE__ */ new Map();
+    const orderedKeys = [];
+    for (const it of items) {
+      let scope = makeBlockScope(it);
+      const key = keyFor(it, scope);
+      orderedKeys.push(key);
+      const existing = blocks.get(key);
+      if (existing) {
+        existing.scope[itemName] = it.value;
+        if (indexName) existing.scope[indexName] = it.objectKey ?? it.index;
+        next.set(key, existing);
+        blocks.delete(key);
+      } else {
+        const node = blueprint.cloneNode(true);
+        utils.initTree(node, [...parentScopes, scope]);
+        next.set(key, { node, scope });
+      }
+    }
+    for (const block of blocks.values()) {
+      utils.destroyTree(block.node);
+      block.node.remove();
+    }
+    for (const key of orderedKeys) {
+      const block = next.get(key);
+      parent.insertBefore(block.node, anchor2);
+    }
+    blocks = next;
+  });
+  utils.cleanup(clear);
+};
+
+// src/directives/teleport.ts
+var teleport = (el, meta2, utils) => {
+  if (el.tagName !== "TEMPLATE") {
+    warn("E501", "s-teleport must be used on a <template> element.", { el, doc: "s-teleport" });
+    return;
+  }
+  const selector = meta2.expression || meta2.value || "";
+  const target = selector ? document.querySelector(selector) : null;
+  if (!target) {
+    warn("E502", `s-teleport target not found: "${selector}".`, {
+      el,
+      doc: "s-teleport",
+      hint: "The target must be a CSS selector that already exists in the DOM, e.g. body."
+    });
+    return;
+  }
+  const content = el.content;
+  const clones = Array.from(content.children).map((n) => n.cloneNode(true));
+  const frag = document.createDocumentFragment();
+  for (const c of clones) frag.appendChild(c);
+  if (meta2.modifiers.includes("prepend")) target.parentNode?.insertBefore(frag, target);
+  else if (meta2.modifiers.includes("append")) target.parentNode?.insertBefore(frag, target.nextSibling);
+  else target.appendChild(frag);
+  for (const c of clones) utils.initTree(c, utils.scopes);
+  utils.cleanup(() => {
+    for (const c of clones) {
+      utils.destroyTree(c);
+      c.remove();
+    }
+  });
+};
+
+// src/idstore.ts
+var counter = 0;
+var groups = /* @__PURE__ */ new WeakMap();
+function allocGroup(el, names) {
+  let map = groups.get(el);
+  if (!map) groups.set(el, map = /* @__PURE__ */ new Map());
+  for (const name of names) map.set(name, ++counter);
+}
+function resolveId(el, name, key) {
+  let cur = el;
+  while (cur) {
+    const map = groups.get(cur);
+    if (map && map.has(name)) {
+      const base2 = `${name}-${map.get(name)}`;
+      return key != null ? `${base2}-${key}` : base2;
+    }
+    cur = cur.parentElement;
+  }
+  const base = `${name}-${++counter}`;
+  return key != null ? `${base}-${key}` : base;
+}
+
+// src/directives/misc.ts
+var init = (_el, meta2, utils) => {
+  utils.evaluateAction(meta2.expression);
+};
+var effect2 = (_el, meta2, utils) => {
+  utils.effect(() => {
+    utils.evaluateAction(meta2.expression);
+  });
+};
+var ref = (el, meta2, utils) => {
+  const evaluated = utils.evaluate(meta2.expression);
+  const name = typeof evaluated === "string" && evaluated ? evaluated : meta2.expression.trim();
+  const refs = refsFor(el);
+  refs[name] = el;
+  utils.cleanup(() => {
+    if (refs[name] === el) delete refs[name];
+  });
+};
+var id = (el, meta2, utils) => {
+  const names = utils.evaluate(meta2.expression);
+  if (Array.isArray(names)) allocGroup(el, names.map(String));
+};
+var cloak = (el) => {
+  el.removeAttribute("s-cloak");
+};
+
+// src/directives/observe.ts
+var intersect = (el, meta2, utils) => {
+  if (typeof IntersectionObserver === "undefined") return;
+  const onLeave = meta2.value === "leave";
+  const threshold = meta2.modifiers.includes("full") ? 0.99 : meta2.modifiers.includes("half") ? 0.5 : 0;
+  const once = meta2.modifiers.includes("once");
+  const io = new IntersectionObserver(
+    (entries) => {
+      for (const entry of entries) {
+        const active = onLeave ? !entry.isIntersecting : entry.isIntersecting;
+        if (!active) continue;
+        utils.evaluateAction(meta2.expression);
+        if (once) io.disconnect();
+      }
+    },
+    { threshold }
+  );
+  io.observe(el);
+  utils.cleanup(() => io.disconnect());
+};
+var resize = (el, meta2, utils) => {
+  if (typeof ResizeObserver === "undefined") return;
+  const ro = new ResizeObserver((entries) => {
+    const box = entries[0]?.contentRect;
+    utils.evaluateAction(meta2.expression, { $width: box?.width ?? 0, $height: box?.height ?? 0 });
+  });
+  ro.observe(el);
+  utils.cleanup(() => ro.disconnect());
+};
+
+// src/directives/focusable.ts
+var SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled]):not([type=hidden])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])",
+  "[contenteditable]"
+].join(",");
+function visible(el) {
+  const r = el.getBoundingClientRect();
+  if (r.width === 0 && r.height === 0) {
+    return el.offsetParent !== null || typeof el.offsetParent === "undefined";
+  }
+  return true;
+}
+function focusable(root) {
+  return Array.from(root.querySelectorAll(SELECTOR)).filter(visible);
+}
+
+// src/directives/focus.ts
+var trap = (el, meta2, utils) => {
+  let active = false;
+  let released = null;
+  const onKeydown = (e) => {
+    if (e.key !== "Tab") return;
+    const items = focusable(el);
+    if (!items.length) {
+      e.preventDefault();
+      return;
+    }
+    const first = items[0];
+    const last = items[items.length - 1];
+    const current = document.activeElement;
+    if (e.shiftKey && (current === first || !el.contains(current))) {
+      e.preventDefault();
+      last.focus();
+    } else if (!e.shiftKey && current === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  };
+  const enable = () => {
+    if (active) return;
+    active = true;
+    released = document.activeElement;
+    document.addEventListener("keydown", onKeydown, true);
+    const focusFirst = () => {
+      const items = focusable(el);
+      (items[0] ?? el).focus?.();
+    };
+    if (typeof requestAnimationFrame === "function") requestAnimationFrame(focusFirst);
+    else focusFirst();
+  };
+  const disable = () => {
+    if (!active) return;
+    active = false;
+    document.removeEventListener("keydown", onKeydown, true);
+    released?.focus?.();
+  };
+  utils.effect(() => {
+    if (utils.evaluate(meta2.expression)) enable();
+    else disable();
+  });
+  utils.cleanup(disable);
+};
+
+// src/directives/anchor.ts
+var anchor = (el, meta2, utils) => {
+  const mods = meta2.modifiers;
+  const placement = mods.includes("top") ? "top" : "bottom";
+  const align = mods.includes("end") ? "end" : mods.includes("center") ? "center" : "start";
+  const oi = mods.indexOf("offset");
+  const gap = oi >= 0 && /^\d+$/.test(mods[oi + 1] ?? "") ? Number(mods[oi + 1]) : 8;
+  const node = el;
+  node.style.position = "fixed";
+  if (!node.style.zIndex) node.style.zIndex = "50";
+  node.style.margin = "0";
+  let ref2 = null;
+  const place = () => {
+    if (!ref2 || typeof window === "undefined") return;
+    const r = ref2.getBoundingClientRect();
+    const ew = node.offsetWidth;
+    const eh = node.offsetHeight;
+    const vh = window.innerHeight;
+    const vw = window.innerWidth;
+    let top = placement === "top" ? r.top - eh - gap : r.bottom + gap;
+    if (placement === "bottom" && top + eh > vh && r.top - eh - gap >= 0) top = r.top - eh - gap;
+    if (placement === "top" && top < 0 && r.bottom + gap + eh <= vh) top = r.bottom + gap;
+    let left = align === "end" ? r.right - ew : align === "center" ? r.left + r.width / 2 - ew / 2 : r.left;
+    left = Math.max(8, Math.min(left, vw - ew - 8));
+    node.style.top = `${Math.round(top)}px`;
+    node.style.left = `${Math.round(left)}px`;
+  };
+  utils.effect(() => {
+    const value = utils.evaluate(meta2.expression);
+    ref2 = value && typeof value.getBoundingClientRect === "function" ? value : null;
+    if (ref2) place();
+  });
+  if (typeof window !== "undefined") {
+    const on2 = () => place();
+    window.addEventListener("scroll", on2, true);
+    window.addEventListener("resize", on2);
+    utils.cleanup(() => {
+      window.removeEventListener("scroll", on2, true);
+      window.removeEventListener("resize", on2);
+    });
+  }
+};
+
+// src/directives/collapse.ts
+var DURATION = 250;
+var collapse = (el, meta2, utils) => {
+  const node = el;
+  node.style.overflow = "hidden";
+  let first = true;
+  utils.effect(() => {
+    const open = !!utils.evaluate(meta2.expression);
+    if (first) {
+      first = false;
+      node.style.height = open ? "auto" : "0px";
+      if (!open) node.setAttribute("hidden", "until-found");
+      return;
+    }
+    node.removeAttribute("hidden");
+    const start2 = node.getBoundingClientRect().height;
+    node.style.height = `${start2}px`;
+    const end = open ? node.scrollHeight : 0;
+    const animate = () => {
+      node.style.transition = `height ${DURATION}ms ease`;
+      node.style.height = `${end}px`;
+    };
+    if (typeof requestAnimationFrame === "function") requestAnimationFrame(animate);
+    else animate();
+    const done = () => {
+      node.style.transition = "";
+      if (open) node.style.height = "auto";
+      node.removeEventListener("transitionend", done);
+    };
+    node.addEventListener("transitionend", done);
+  });
+};
+
+// src/directives/mask.ts
+function matches(token, ch) {
+  if (token === "9") return /\d/.test(ch);
+  if (token === "a") return /[a-zA-Z]/.test(ch);
+  if (token === "*") return /[a-zA-Z0-9]/.test(ch);
+  return false;
+}
+function applyMask(value, pattern) {
+  let out = "";
+  let ci = 0;
+  for (const token of pattern) {
+    if (ci >= value.length) break;
+    if (token === "9" || token === "a" || token === "*") {
+      while (ci < value.length) {
+        const ch = value[ci++];
+        if (matches(token, ch)) {
+          out += ch;
+          break;
+        }
+      }
+    } else {
+      out += token;
+      if (value[ci] === token) ci++;
+    }
+  }
+  return out;
+}
+var mask = (el, meta2, utils) => {
+  const input = el;
+  const pattern = String(utils.evaluate(meta2.expression) ?? meta2.expression);
+  const format = () => {
+    input.value = applyMask(input.value, pattern);
+  };
+  input.addEventListener("input", format);
+  if (input.value) format();
+  utils.cleanup(() => input.removeEventListener("input", format));
+};
+
+// src/directives/index.ts
+function registerBuiltinDirectives() {
+  registerDirective("ref", ref, 10);
+  registerDirective("id", id, 15);
+  registerDirective("if", sIf, 20);
+  registerDirective("for", sFor, 20);
+  registerDirective("teleport", teleport, 20);
+  registerDirective("bind", bind, 50);
+  registerDirective("mask", mask, 55);
+  registerDirective("model", model, 60);
+  registerDirective("on", on, 70);
+  registerDirective("text", text, 80);
+  registerDirective("html", html, 80);
+  registerDirective("transition", transition, 85);
+  registerDirective("anchor", anchor, 88);
+  registerDirective("collapse", collapse, 89);
+  registerDirective("show", show, 90);
+  registerDirective("trap", trap, 95);
+  registerDirective("effect", effect2, 100);
+  registerDirective("intersect", intersect, 100);
+  registerDirective("resize", resize, 100);
+  registerDirective("init", init, 200);
+  registerDirective("cloak", cloak, 1e3);
+}
+
+// src/magics/focus.ts
+function makeFocus(root) {
+  const items = () => focusable(root);
+  const at = (delta) => {
+    const f = items();
+    if (!f.length) return;
+    const i = f.indexOf(document.activeElement);
+    const next = i === -1 ? 0 : (i + delta + f.length) % f.length;
+    f[next]?.focus();
+  };
+  return {
+    focus(target) {
+      target?.focus?.();
+    },
+    first() {
+      items()[0]?.focus();
+    },
+    last() {
+      const f = items();
+      f[f.length - 1]?.focus();
+    },
+    next() {
+      at(1);
+    },
+    previous() {
+      at(-1);
+    },
+    within(el) {
+      return makeFocus(el);
+    }
+  };
+}
+
+// src/magics/index.ts
+function registerBuiltinMagics() {
+  registerMagic("el", (ctx) => ctx.el);
+  registerMagic("refs", (ctx) => refsFor(ctx.el));
+  registerMagic("root", (ctx) => closestRoot(ctx.el));
+  registerMagic("data", (ctx) => ctx.scopes.length ? ctx.scopes[ctx.scopes.length - 1] : {});
+  registerMagic("store", () => getStoreRoot());
+  registerMagic("watch", (ctx) => (path, callback) => {
+    let oldValue;
+    let first = true;
+    const dispose = domEffect(() => {
+      const newValue = ctx.evaluate(path);
+      if (first) {
+        oldValue = newValue;
+        first = false;
+        return;
+      }
+      if (Object.is(newValue, oldValue)) return;
+      const previous = oldValue;
+      oldValue = newValue;
+      callback(newValue, previous);
+    });
+    ctx.cleanup(dispose);
+    return dispose;
+  });
+  registerMagic(
+    "dispatch",
+    (ctx) => (name, detail, options = {}) => {
+      const event = new CustomEvent(name, {
+        detail,
+        bubbles: true,
+        composed: true,
+        cancelable: true,
+        ...options
+      });
+      return ctx.el.dispatchEvent(event);
+    }
+  );
+  registerMagic("nextTick", () => (callback) => nextTick(callback));
+  registerMagic("id", (ctx) => (name, key) => resolveId(ctx.el, name, key));
+  registerMagic("persist", () => (initial) => createPersist(initial));
+  registerMagic("focus", (ctx) => makeFocus(ctx.el));
+}
+
+// src/summit.ts
+var version = "0.1.0";
+var started = false;
+function dispatch(name) {
+  if (typeof document !== "undefined") document.dispatchEvent(new CustomEvent(name));
+}
+function start(root) {
+  if (started) return;
+  started = true;
+  const el = root ?? (typeof document !== "undefined" ? document.body : void 0);
+  if (!el) return;
+  dispatch("summit:init");
+  initTree(el);
+  startObserver(el.ownerDocument?.body ?? el);
+  dispatch("summit:initialized");
+}
+var Summit = {
+  version,
+  started: () => started,
+  start,
+  data(name, provider) {
+    registerData(name, provider);
+    return this;
+  },
+  directive(name, handler, priority) {
+    registerDirective(name, handler, priority);
+    return this;
+  },
+  magic(name, factory) {
+    registerMagic(name, factory);
+    return this;
+  },
+  bind(name, provider) {
+    registerBind(name, provider);
+    return this;
+  },
+  store(name, value) {
+    if (value === void 0) return getStore(name);
+    if (value !== null && typeof value === "object") {
+      const scoped = createScope(value);
+      setStore(name, scoped);
+      const initFn = scoped["init"];
+      if (typeof initFn === "function") {
+        try {
+          initFn();
+        } catch (err) {
+          fail("E103", `store "${name}" init() threw.`, { doc: "globals-store", cause: err });
+        }
+      }
+      return scoped;
+    }
+    setStore(name, value);
+    return getStore(name);
+  },
+  plugin(fn) {
+    fn(this);
+    return this;
+  },
+  addGlobals(names) {
+    addGlobals(names);
+    return this;
+  },
+  getBind,
+  signal,
+  computed,
+  effect,
+  reactive,
+  batch,
+  nextTick,
+  initTree,
+  destroyTree
+};
+registerBuiltinDirectives();
+registerBuiltinMagics();
+setSummitGlobal(Summit);
+var summit_default = Summit;
+
+// src/index.ts
+var src_default = summit_default;
+
+export { Summit, addGlobals, batch, computed, src_default as default, effect, evaluateAction, evaluateExpression, isReactive, isSignal, nextTick, reactive, signal, stop, toRaw, untrack, version };
+//# sourceMappingURL=summit.js.map
+//# sourceMappingURL=summit.js.map