@sky.ui/reactivity 0.0.1

package/dist/index.js

@@ -0,0 +1,2671 @@
+import * as acorn from 'acorn';
+
+// src/reactivity/tracking.ts
+var targetMap = /* @__PURE__ */ new WeakMap();
+var runnerDeps = /* @__PURE__ */ new WeakMap();
+var activeEffect = null;
+var effectStack = [];
+var ITERATE_KEY = /* @__PURE__ */ Symbol("iterate");
+function enterEffectScope(runner) {
+  effectStack.push(runner);
+  activeEffect = runner;
+}
+function leaveEffectScope() {
+  effectStack.pop();
+  activeEffect = effectStack[effectStack.length - 1] ?? null;
+}
+function cleanupRunnerDeps(runner) {
+  const links = runnerDeps.get(runner);
+  if (!links) return;
+  for (const { target, key } of links) {
+    targetMap.get(target)?.get(key)?.delete(runner);
+  }
+  links.length = 0;
+}
+function stopRunner(runner) {
+  runner.stopped = true;
+  runner.paused = false;
+  cleanupRunnerDeps(runner);
+  runnerDeps.delete(runner);
+}
+function track(target, key) {
+  if (!activeEffect || activeEffect.stopped || activeEffect.paused) return;
+  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());
+  if (!dep.has(activeEffect)) {
+    dep.add(activeEffect);
+    let links = runnerDeps.get(activeEffect);
+    if (!links) runnerDeps.set(activeEffect, links = []);
+    links.push({ target, key });
+  }
+}
+function trigger(target, key) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) return;
+  const dep = depsMap.get(key);
+  if (!dep) return;
+  dep.forEach((e) => {
+    if (!e.stopped && !e.paused) e.scheduler(e);
+  });
+}
+
+// src/reactivity/scheduler.ts
+var jobQueue = /* @__PURE__ */ new Set();
+var nextTickQueue = /* @__PURE__ */ new Set();
+var flushing = false;
+var flushPromise = null;
+function flushJobs() {
+  jobQueue.forEach((j) => j());
+  jobQueue.clear();
+  flushing = false;
+  nextTickQueue.forEach((fn) => fn());
+  nextTickQueue.clear();
+  flushPromise = null;
+}
+function scheduleFlush() {
+  if (flushing) return;
+  flushing = true;
+  flushPromise ??= Promise.resolve().then(flushJobs);
+}
+function queueJob(job) {
+  jobQueue.add(job);
+  scheduleFlush();
+}
+function queueNextTick(fn) {
+  nextTickQueue.add(fn);
+  scheduleFlush();
+}
+function flushSync(fn) {
+  fn();
+  if (flushing || jobQueue.size > 0) {
+    flushJobs();
+  } else {
+    nextTickQueue.forEach((f) => f());
+    nextTickQueue.clear();
+  }
+}
+
+// src/reactivity/effect-scope.ts
+var EffectScope = class {
+  constructor(detached = false) {
+    this.detached = detached;
+  }
+  detached;
+  active = true;
+  effects = [];
+  disposers = [];
+  run(fn) {
+    if (!this.active) return fn();
+    const prev = activeScope;
+    activeScope = this;
+    try {
+      return fn();
+    } finally {
+      activeScope = prev;
+    }
+  }
+  register(runner) {
+    if (!this.active) {
+      runner.stop();
+      return;
+    }
+    this.effects.push(runner);
+  }
+  registerDispose(fn) {
+    if (!this.active) {
+      fn();
+      return;
+    }
+    this.disposers.push(fn);
+  }
+  stop() {
+    if (!this.active) return;
+    this.active = false;
+    for (const d of this.disposers) d();
+    this.disposers.length = 0;
+    for (const e of this.effects) e.stop();
+    this.effects.length = 0;
+  }
+};
+var activeScope = null;
+function effectScope(detached = false) {
+  return new EffectScope(detached);
+}
+function getCurrentScope() {
+  return activeScope;
+}
+function onScopeDispose(fn) {
+  activeScope?.registerDispose(fn);
+}
+
+// src/reactivity/effect.ts
+function effect(fn, opts = {}) {
+  let cleanupFn;
+  const runner = (() => {
+    if (runner.stopped || runner.paused) return;
+    if (cleanupFn) {
+      cleanupFn();
+      cleanupFn = void 0;
+    }
+    cleanupRunnerDeps(runner);
+    try {
+      enterEffectScope(runner);
+      return fn();
+    } finally {
+      leaveEffectScope();
+    }
+  });
+  runner.stopped = false;
+  runner.paused = false;
+  runner.stop = () => stopRunner(runner);
+  runner.pause = () => {
+    runner.paused = true;
+  };
+  runner.resume = () => {
+    if (runner.stopped) return;
+    runner.paused = false;
+    runner();
+  };
+  runner.scheduler = opts.scheduler ?? queueJob;
+  if (opts.onCleanup) {
+    cleanupFn = opts.onCleanup;
+  }
+  getCurrentScope()?.register(runner);
+  if (!opts.lazy) runner();
+  return runner;
+}
+var watchEffect = effect;
+
+// src/reactivity/ref-flags.ts
+var REF_FLAG = "__isRef";
+function isRef(v) {
+  return !!(v && typeof v === "object" && v[REF_FLAG] === true);
+}
+function unref(v) {
+  return isRef(v) ? v.value : v;
+}
+
+// src/reactivity/proxy-state.ts
+function isPlainObject(o) {
+  if (!o || typeof o !== "object") return false;
+  const p = Object.getPrototypeOf(o);
+  return p === Object.prototype || p === null;
+}
+function shouldWrap(v) {
+  return Array.isArray(v) || isPlainObject(v);
+}
+var proxyCache = /* @__PURE__ */ new WeakMap();
+var proxyToRaw = /* @__PURE__ */ new WeakMap();
+var markRawSet = /* @__PURE__ */ new WeakSet();
+var readonlyProxyCache = /* @__PURE__ */ new WeakMap();
+var READONLY_FLAG = "__isReadonly";
+
+// src/reactivity/reactive.ts
+function reactive(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (obj.__isReactive) return obj;
+  if (markRawSet.has(obj)) return obj;
+  const cached = proxyCache.get(obj);
+  if (cached) return cached;
+  if (Array.isArray(obj)) {
+    const arrayMethods = [
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "splice",
+      "sort",
+      "reverse"
+    ];
+    const p2 = new Proxy(obj, {
+      get(target, key, receiver) {
+        if (key === "__isReactive") return true;
+        if (typeof key === "string" && arrayMethods.includes(key)) {
+          return function(...args) {
+            const oldLength = target.length;
+            const mutator = key;
+            const proto = Array.prototype;
+            const fn = proto[mutator];
+            if (!fn) return void 0;
+            const result = fn.apply(target, args);
+            if (target.length !== oldLength) trigger(target, "length");
+            if (key === "push" || key === "unshift" || key === "splice") {
+              for (let i = 0; i < target.length; i++) trigger(target, i + "");
+            }
+            return result;
+          };
+        }
+        const value = Reflect.get(target, key, receiver);
+        track(target, key);
+        return shouldWrap(value) ? reactive(value) : value;
+      },
+      set(target, key, value, receiver) {
+        const old = Reflect.get(target, key);
+        const result = Reflect.set(target, key, value, receiver);
+        if (old !== value) {
+          trigger(target, key);
+          if (typeof key === "string" && key !== "" && !Number.isNaN(Number(key))) {
+            trigger(target, key);
+          }
+        }
+        return result;
+      },
+      has(target, key) {
+        track(target, key);
+        return Reflect.has(target, key);
+      },
+      deleteProperty(target, key) {
+        const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+        const result = Reflect.deleteProperty(target, key);
+        if (hadKey) {
+          trigger(target, key);
+          trigger(target, "length");
+        }
+        return result;
+      }
+    });
+    proxyCache.set(obj, p2);
+    proxyToRaw.set(p2, obj);
+    return p2;
+  }
+  const p = new Proxy(obj, {
+    get(t, k, r) {
+      if (k === "__isReactive") return true;
+      const v = Reflect.get(t, k, r);
+      track(t, k);
+      if (isRef(v)) {
+        const u = v.value;
+        return shouldWrap(u) ? reactive(u) : u;
+      }
+      return shouldWrap(v) ? reactive(v) : v;
+    },
+    set(t, k, v, r) {
+      const old = Reflect.get(t, k);
+      const hadKey = Object.prototype.hasOwnProperty.call(t, k);
+      const res = Reflect.set(t, k, v, r);
+      if (old !== v) {
+        trigger(t, k);
+        if (!hadKey) trigger(t, ITERATE_KEY);
+      }
+      return res;
+    },
+    has(t, k) {
+      track(t, k);
+      return Reflect.has(t, k);
+    },
+    deleteProperty(t, k) {
+      const hadKey = Object.prototype.hasOwnProperty.call(t, k);
+      const res = Reflect.deleteProperty(t, k);
+      if (hadKey) {
+        trigger(t, k);
+        trigger(t, ITERATE_KEY);
+      }
+      return res;
+    },
+    ownKeys(t) {
+      track(t, ITERATE_KEY);
+      return Reflect.ownKeys(t);
+    }
+  });
+  proxyCache.set(obj, p);
+  proxyToRaw.set(p, obj);
+  return p;
+}
+
+// src/reactivity/readonly.ts
+function readonly(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (obj[READONLY_FLAG]) return obj;
+  if (markRawSet.has(obj)) return obj;
+  const cached = readonlyProxyCache.get(obj);
+  if (cached) return cached;
+  const p = new Proxy(obj, {
+    get(t, k, r) {
+      if (k === "__isReactive" || k === READONLY_FLAG) return true;
+      const v = Reflect.get(t, k, r);
+      track(t, k);
+      if (isRef(v)) {
+        const u = v.value;
+        return shouldWrap(u) ? readonly(u) : u;
+      }
+      return shouldWrap(v) ? readonly(v) : v;
+    },
+    set() {
+      return true;
+    },
+    has(t, k) {
+      track(t, k);
+      return Reflect.has(t, k);
+    },
+    deleteProperty() {
+      return true;
+    },
+    ownKeys(t) {
+      track(t, ITERATE_KEY);
+      return Reflect.ownKeys(t);
+    }
+  });
+  readonlyProxyCache.set(obj, p);
+  proxyToRaw.set(p, obj);
+  return p;
+}
+
+// src/reactivity/shallow-reactive.ts
+var shallowProxyCache = /* @__PURE__ */ new WeakMap();
+function shallowReactive(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (obj.__isReactive) return obj;
+  if (markRawSet.has(obj)) return obj;
+  const cached = shallowProxyCache.get(obj);
+  if (cached) return cached;
+  const p = new Proxy(obj, {
+    get(t, k, r) {
+      if (k === "__isReactive") return true;
+      const v = Reflect.get(t, k, r);
+      track(t, k);
+      if (isRef(v)) return v.value;
+      return v;
+    },
+    set(t, k, v, r) {
+      const old = Reflect.get(t, k);
+      const hadKey = Object.prototype.hasOwnProperty.call(t, k);
+      const res = Reflect.set(t, k, v, r);
+      if (old !== v) {
+        trigger(t, k);
+        if (!hadKey) trigger(t, ITERATE_KEY);
+      }
+      return res;
+    },
+    has(t, k) {
+      track(t, k);
+      return Reflect.has(t, k);
+    },
+    deleteProperty(t, k) {
+      const hadKey = Object.prototype.hasOwnProperty.call(t, k);
+      const res = Reflect.deleteProperty(t, k);
+      if (hadKey) {
+        trigger(t, k);
+        trigger(t, ITERATE_KEY);
+      }
+      return res;
+    },
+    ownKeys(t) {
+      track(t, ITERATE_KEY);
+      return Reflect.ownKeys(t);
+    }
+  });
+  shallowProxyCache.set(obj, p);
+  proxyToRaw.set(p, obj);
+  return p;
+}
+
+// src/reactivity/shallow-readonly.ts
+var shallowReadonlyCache = /* @__PURE__ */ new WeakMap();
+function shallowReadonly(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (markRawSet.has(obj)) return obj;
+  const cached = shallowReadonlyCache.get(obj);
+  if (cached) return cached;
+  const p = new Proxy(obj, {
+    get(t, k, r) {
+      if (k === "__isReactive" || k === READONLY_FLAG) return true;
+      const v = Reflect.get(t, k, r);
+      track(t, k);
+      if (isRef(v)) return v.value;
+      return v;
+    },
+    set() {
+      return true;
+    },
+    has(t, k) {
+      track(t, k);
+      return Reflect.has(t, k);
+    },
+    deleteProperty() {
+      return true;
+    },
+    ownKeys(t) {
+      track(t, ITERATE_KEY);
+      return Reflect.ownKeys(t);
+    }
+  });
+  shallowReadonlyCache.set(obj, p);
+  proxyToRaw.set(p, obj);
+  return p;
+}
+
+// src/reactivity/proxy-api.ts
+function toRaw(proxy) {
+  return proxyToRaw.get(proxy) ?? proxy;
+}
+function markRaw(obj) {
+  if (obj != null && typeof obj === "object") markRawSet.add(obj);
+  return obj;
+}
+function isReactive(obj) {
+  return !!(obj && typeof obj === "object" && obj.__isReactive === true);
+}
+function isReadonly(obj) {
+  return !!(obj && typeof obj === "object" && obj[READONLY_FLAG] === true);
+}
+
+// src/types.ts
+var SHALLOW_REF_TARGET = /* @__PURE__ */ Symbol("shallowRefTarget");
+
+// src/reactivity/ref.ts
+function ref(v) {
+  const r = reactive({ value: v });
+  Object.defineProperty(r, REF_FLAG, { value: true });
+  return r;
+}
+function shallowRef(v) {
+  const inner = { value: v };
+  const shallow = {
+    get value() {
+      track(inner, "value");
+      return inner.value;
+    },
+    set value(val) {
+      inner.value = val;
+      trigger(inner, "value");
+    }
+  };
+  Object.defineProperty(shallow, REF_FLAG, { value: true });
+  Object.defineProperty(shallow, SHALLOW_REF_TARGET, { value: inner });
+  return shallow;
+}
+function triggerRef(r) {
+  const inner = r && isRef(r) ? r[SHALLOW_REF_TARGET] : void 0;
+  if (inner) trigger(inner, "value");
+}
+function customRef(factory) {
+  const inner = { value: void 0 };
+  const trackDep = () => track(inner, "value");
+  const triggerDep = () => trigger(inner, "value");
+  const { get, set } = factory(trackDep, triggerDep);
+  const r = {
+    get value() {
+      trackDep();
+      return get();
+    },
+    set value(v) {
+      set(v);
+      triggerDep();
+    }
+  };
+  Object.defineProperty(r, REF_FLAG, { value: true });
+  return r;
+}
+
+// src/reactivity/to-ref.ts
+function toRef(object, key) {
+  const r = {
+    get value() {
+      const v = object[key];
+      return isRef(v) ? v.value : v;
+    },
+    set value(val) {
+      const cur = object[key];
+      if (isRef(cur)) cur.value = val;
+      else object[key] = val;
+    }
+  };
+  Object.defineProperty(r, REF_FLAG, { value: true });
+  return r;
+}
+function toRefs(object) {
+  const ret = {};
+  for (const key of Object.keys(object)) {
+    ret[key] = toRef(object, key);
+  }
+  return ret;
+}
+
+// src/reactivity/computed.ts
+function computed(getterOrOptions) {
+  const onlyGetter = typeof getterOrOptions === "function";
+  const getter = onlyGetter ? getterOrOptions : getterOrOptions.get;
+  const setter = onlyGetter ? void 0 : getterOrOptions.set;
+  const r = ref(void 0);
+  effect(() => {
+    r.value = getter();
+  });
+  if (setter !== void 0) {
+    return {
+      get value() {
+        return r.value;
+      },
+      set value(v) {
+        setter(v);
+      },
+      [REF_FLAG]: true
+    };
+  }
+  return r;
+}
+
+// src/reactivity/watch.ts
+function watch(src, cb, opts = {}) {
+  const { immediate = false, deep = false, flush = "post" } = opts;
+  const isMulti = Array.isArray(src);
+  const getter = isMulti ? () => src.map((s) => typeof s === "function" ? s() : unref(s)) : typeof src === "function" ? src : () => unref(src);
+  const traverse = (v, seen = /* @__PURE__ */ new Set()) => {
+    v = unref(v);
+    if (!v || typeof v !== "object" || seen.has(v)) return v;
+    seen.add(v);
+    if (Array.isArray(v)) {
+      v.length;
+      for (let i = 0; i < v.length; i++) traverse(v[i], seen);
+    } else {
+      const record = v;
+      for (const k in record) traverse(record[k], seen);
+    }
+    return v;
+  };
+  let old;
+  let cleanup2;
+  const run = () => {
+    if (cleanup2) {
+      cleanup2();
+      cleanup2 = void 0;
+    }
+    const val = getter();
+    if (deep) traverse(val);
+    const prev = old;
+    const shouldCall = prev !== void 0 || immediate;
+    old = val;
+    if (shouldCall) {
+      const onCleanup = (fn) => {
+        cleanup2 = fn;
+      };
+      cb(val, prev, onCleanup);
+    }
+  };
+  const scheduler = flush === "sync" ? (runFn) => runFn() : (runFn) => queueJob(runFn);
+  const runner = effect(run, { lazy: !immediate, scheduler });
+  return () => runner.stop();
+}
+
+// src/reactivity/next-tick.ts
+var nextTick = (fn) => {
+  if (fn) {
+    return new Promise((resolve) => {
+      queueNextTick(() => {
+        fn();
+        resolve();
+      });
+    });
+  }
+  return new Promise((resolve) => {
+    queueNextTick(() => resolve());
+  });
+};
+var exprCache = /* @__PURE__ */ new Map();
+var stmtCache = /* @__PURE__ */ new Map();
+function stripSemi(s) {
+  return String(s || "").trim().replace(/;+\s*$/g, "");
+}
+function parseExpr(expr) {
+  const src = stripSemi(expr) || "undefined";
+  let ast = exprCache.get(src);
+  if (!ast) {
+    try {
+      const program = acorn.parse(`(${src})`, {
+        ecmaVersion: "latest",
+        sourceType: "script"
+      });
+      const first = program.body[0];
+      if (first?.type !== "ExpressionStatement") {
+        throw new SyntaxError(`[Sky parseExpr] Expected expression, got ${first?.type ?? "empty"}`);
+      }
+      ast = first.expression;
+      exprCache.set(src, ast);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new SyntaxError(`[Sky parseExpr] ${msg}
+SRC: ${src}`);
+    }
+  }
+  return ast;
+}
+function parseStmt(code) {
+  code = String(code || "").trim();
+  if (!stmtCache.has(code)) {
+    const program = acorn.parse(code, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      allowAwaitOutsideFunction: true,
+      allowReturnOutsideFunction: true
+    });
+    stmtCache.set(code, program);
+  }
+  const cached = stmtCache.get(code);
+  if (!cached) throw new SyntaxError("[Sky parseStmt] failed to parse");
+  return cached;
+}
+function compileExpr(expr) {
+  return parseExpr(expr);
+}
+function compileStmt(code) {
+  return parseStmt(code);
+}
+function clearAstCaches() {
+  exprCache.clear();
+  stmtCache.clear();
+}
+
+// src/ast/constants.ts
+var SAFE_GLOBALS = Object.freeze({
+  Math,
+  Number,
+  String,
+  Boolean,
+  Array,
+  Object,
+  JSON,
+  Date,
+  RegExp,
+  parseInt,
+  parseFloat,
+  isNaN,
+  isFinite,
+  console
+  // optional
+});
+var BLOCKED_PROPS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var BLOCKED_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "window",
+  "self",
+  "document",
+  "globalThis",
+  "Function",
+  "eval",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "location",
+  "localStorage",
+  "sessionStorage",
+  "indexedDB",
+  "navigator",
+  "fetch",
+  "XMLHttpRequest",
+  "WebSocket"
+]);
+
+// src/shared/env.ts
+function getSkyDev() {
+  if (typeof globalThis.__SKY_DEV__ === "boolean") {
+    return globalThis.__SKY_DEV__;
+  }
+  return typeof process !== "undefined" && process.env.NODE_ENV === "production" ? false : true;
+}
+function setSkyDev(enabled) {
+  globalThis.__SKY_DEV__ = enabled;
+}
+var skyDevSnapshot = getSkyDev();
+
+// src/shared/warn-codes.ts
+var WarnCodes = {
+  MODEL_ARG_ON_NATIVE: "MODEL_ARG_ON_NATIVE",
+  MODEL_INVALID_KEY: "MODEL_INVALID_KEY",
+  MODEL_UNKNOWN_MODIFIER: "MODEL_UNKNOWN_MODIFIER",
+  MODEL_DUPLICATE: "MODEL_DUPLICATE",
+  FOR_KEY_RECOMMENDED: "FOR_KEY_RECOMMENDED",
+  FOR_INVALID_SYNTAX: "FOR_INVALID_SYNTAX",
+  EVENT_UNKNOWN_MODIFIER: "EVENT_UNKNOWN_MODIFIER",
+  HANDLER_RUNTIME: "HANDLER_RUNTIME",
+  AST_EVAL: "AST_EVAL",
+  AST_STMT: "AST_STMT",
+  AST_BLOCKED: "AST_BLOCKED",
+  MOUNT_TARGET_NOT_FOUND: "MOUNT_TARGET_NOT_FOUND",
+  SSR_ROOT_NOT_FOUND: "SSR_ROOT_NOT_FOUND",
+  SKY_HTML_UNSAFE: "SKY_HTML_UNSAFE"
+};
+var messages = {
+  [WarnCodes.MODEL_ARG_ON_NATIVE]: 'sky-model:{arg} is for custom elements only. On <{tag}> use sky-model="{key}" without an argument.',
+  [WarnCodes.MODEL_INVALID_KEY]: 'Invalid sky-model value "{value}". Expected a single identifier (e.g. sky-model="count").',
+  [WarnCodes.MODEL_UNKNOWN_MODIFIER]: 'Unknown sky-model modifier(s) "{mods}". Supported: .lazy, .number, .trim.',
+  [WarnCodes.MODEL_DUPLICATE]: "Multiple sky-model bindings on the same element. Only one is applied.",
+  [WarnCodes.FOR_KEY_RECOMMENDED]: 'sky-for without sky-key may recreate DOM nodes on list updates. Add sky-key="item.id" (or a stable key).',
+  [WarnCodes.FOR_INVALID_SYNTAX]: 'Invalid sky-for="{expr}". Use `item in items` or `(item, index) in items`.',
+  [WarnCodes.EVENT_UNKNOWN_MODIFIER]: 'Unknown event modifier "{mod}" on @{event}. Ignored.',
+  [WarnCodes.HANDLER_RUNTIME]: "Unhandled error in event handler{label}.",
+  [WarnCodes.AST_EVAL]: "Expression evaluation failed{label}.",
+  [WarnCodes.AST_STMT]: "Statement execution failed{label}.",
+  [WarnCodes.AST_BLOCKED]: "{detail}",
+  [WarnCodes.MOUNT_TARGET_NOT_FOUND]: 'Failed to mount: target "{target}" was not found.',
+  [WarnCodes.SSR_ROOT_NOT_FOUND]: 'SSR root "{root}" was not found in markup.',
+  [WarnCodes.SKY_HTML_UNSAFE]: "sky-html sets innerHTML from an expression. Only bind trusted content to avoid XSS."
+};
+function getWarnMessage(code, args = {}) {
+  let msg = messages[code] ?? code;
+  for (const [k, v] of Object.entries(args)) {
+    msg = msg.replaceAll(`{${k}}`, String(v));
+  }
+  return msg.replace(/\{(\w+)\}/g, "");
+}
+
+// src/shared/warn.ts
+var warnedKeys = /* @__PURE__ */ new Set();
+var elementIds = /* @__PURE__ */ new WeakMap();
+var nextElementId = 0;
+var customHandler = null;
+function setWarnHandler(handler) {
+  customHandler = handler;
+}
+function elementInstanceKey(el) {
+  if (!el) return "";
+  let id = elementIds.get(el);
+  if (id === void 0) {
+    id = ++nextElementId;
+    elementIds.set(el, id);
+  }
+  return String(id);
+}
+function warnKey(code, context) {
+  return `${code}:${elementInstanceKey(context?.element)}:${context?.label ?? ""}`;
+}
+function formatElement(el) {
+  const tag = el.tagName.toLowerCase();
+  const id = el.id ? `#${el.id}` : "";
+  const extra = describeElement(el);
+  return extra ? `<${tag}${id} ${extra}>` : `<${tag}${id}>`;
+}
+function describeElement(el) {
+  const hints = [];
+  const skyFor = el.getAttribute("sky-for");
+  if (skyFor) {
+    hints.push(
+      `sky-for="${skyFor.slice(0, 48)}${skyFor.length > 48 ? "\u2026" : ""}"`
+    );
+  }
+  const skyIf = el.getAttribute("sky-if") ?? el.getAttribute("sky-else-if");
+  if (skyIf) hints.push(`sky-if="${skyIf.slice(0, 48)}"`);
+  return hints.join(" ");
+}
+function formatTrace(context) {
+  const lines = [];
+  if (context?.element) {
+    lines.push(`  at ${formatElement(context.element)}`);
+  }
+  if (context?.label) {
+    lines.push(`  (${context.label})`);
+  }
+  return lines.length > 0 ? "\n" + lines.join("\n") : "";
+}
+function emitWarn(code, message, context) {
+  if (!getSkyDev()) return;
+  const trace = formatTrace(context);
+  const full = `[Sky warn]: ${message}${trace}`;
+  if (customHandler) {
+    customHandler(code, message, context);
+    return;
+  }
+  console.warn(full);
+}
+function warn(code, args = {}, context) {
+  emitWarn(code, getWarnMessage(code, args), context);
+}
+function warnOnce(code, args = {}, context) {
+  if (!getSkyDev()) return;
+  const key = warnKey(code, context);
+  if (warnedKeys.has(key)) return;
+  warnedKeys.add(key);
+  warn(code, args, context);
+}
+function logError(code, err, context) {
+  if (!getSkyDev()) {
+    if (code === WarnCodes.HANDLER_RUNTIME) {
+      console.error(err);
+    }
+    return;
+  }
+  const labelArg = context?.label ? { label: ` (${context.label})` } : { label: "" };
+  const message = getWarnMessage(code, labelArg);
+  const trace = formatTrace(context);
+  if (customHandler) {
+    customHandler(code, `${message} ${formatErr(err)}`, context);
+    return;
+  }
+  console.warn(`[Sky warn]: ${message}${trace}`);
+  if (err != null) {
+    console.warn(formatErr(err));
+  }
+}
+function formatErr(err) {
+  if (err instanceof Error) {
+    return err.stack ?? err.message;
+  }
+  return String(err);
+}
+function resetWarned() {
+  warnedKeys.clear();
+}
+
+// src/ast/errors.ts
+function fail(msg) {
+  throw new Error("[Sky] " + msg);
+}
+function isObjectLike(v) {
+  return v !== null && (typeof v === "object" || typeof v === "function");
+}
+function assertSafeMemberKey(key) {
+  if (typeof key === "string" && BLOCKED_PROPS.has(key)) {
+    if (getSkyDev()) {
+      warn(
+        WarnCodes.AST_BLOCKED,
+        {
+          detail: `Blocked property access: ${key}. Use a method on context instead.`
+        },
+        { label: "expression" }
+      );
+    }
+    fail(`Blocked property access: ${key}`);
+  }
+}
+function assertSafeIdentifier(name) {
+  if (BLOCKED_IDENTIFIERS.has(name)) {
+    if (getSkyDev()) {
+      warn(
+        WarnCodes.AST_BLOCKED,
+        {
+          detail: `Blocked identifier "${name}" in template code. Expose a safe helper from setup instead.`
+        },
+        { label: "expression" }
+      );
+    }
+    fail(`Blocked identifier: ${name}`);
+  }
+}
+function toKey(v) {
+  return typeof v === "symbol" ? String(v) : v;
+}
+
+// src/ast/scope.ts
+function createScope(ctx, locals = null) {
+  return { ctx, locals: locals ?? /* @__PURE__ */ Object.create(null) };
+}
+function getVar(scope, name) {
+  assertSafeIdentifier(name);
+  if (name in scope.locals) return scope.locals[name];
+  if (name in scope.ctx) return scope.ctx[name];
+  if (name in SAFE_GLOBALS) return SAFE_GLOBALS[name];
+  return void 0;
+}
+function setVar(scope, name, value) {
+  assertSafeIdentifier(name);
+  let cur;
+  let where = "ctx";
+  if (name in scope.locals) {
+    cur = scope.locals[name];
+    where = "locals";
+  } else if (name in scope.ctx) {
+    cur = scope.ctx[name];
+    where = "ctx";
+  } else {
+    cur = void 0;
+    where = "ctx";
+  }
+  if (isRef(cur) && !isRef(value)) {
+    cur.value = value;
+    return value;
+  }
+  if (where === "locals") scope.locals[name] = value;
+  else scope.ctx[name] = value;
+  return value;
+}
+
+// src/ast/member.ts
+function getMember(obj, key) {
+  assertSafeMemberKey(key);
+  if (!isObjectLike(obj)) return void 0;
+  return obj[key];
+}
+function setMember(obj, key, value) {
+  assertSafeMemberKey(key);
+  if (!isObjectLike(obj)) fail("Cannot set property on non-object");
+  obj[key] = value;
+  return value;
+}
+function unwrapRefForMember(obj, key) {
+  if (isRef(obj) && key !== "value") return obj.value;
+  return obj;
+}
+
+// src/ast/operators.ts
+function num(v) {
+  return Number(v);
+}
+function evalBinary(op, a, b) {
+  switch (op) {
+    case "+":
+      return num(a) + num(b);
+    case "-":
+      return num(a) - num(b);
+    case "*":
+      return num(a) * num(b);
+    case "/":
+      return num(a) / num(b);
+    case "%":
+      return num(a) % num(b);
+    case "**":
+      return num(a) ** num(b);
+    case "==":
+      return a == b;
+    case "!=":
+      return a != b;
+    case "===":
+      return a === b;
+    case "!==":
+      return a !== b;
+    case "<":
+      return num(a) < num(b);
+    case "<=":
+      return num(a) <= num(b);
+    case ">":
+      return num(a) > num(b);
+    case ">=":
+      return num(a) >= num(b);
+    case "|":
+      return num(a) | num(b);
+    case "&":
+      return num(a) & num(b);
+    case "^":
+      return num(a) ^ num(b);
+    case "<<":
+      return num(a) << num(b);
+    case ">>":
+      return num(a) >> num(b);
+    case ">>>":
+      return num(a) >>> num(b);
+    case "in":
+      return typeof b === "object" && b !== null && String(a) in b;
+    case "instanceof":
+      return typeof b === "function" && typeof a === "object" && a !== null && a instanceof b;
+    default:
+      fail("Unsupported binary op: " + op);
+  }
+}
+function evalUnary(op, v) {
+  switch (op) {
+    case "+":
+      return +num(v);
+    case "-":
+      return -num(v);
+    case "!":
+      return !v;
+    case "~":
+      return ~num(v);
+    case "typeof":
+      return typeof v;
+    case "void":
+      return void v;
+    case "delete":
+      return true;
+    default:
+      fail("Unsupported unary op: " + op);
+  }
+}
+function applyAssignment(op, leftVal, rightVal) {
+  switch (op) {
+    case "=":
+      return rightVal;
+    case "+=":
+      return num(leftVal) + num(rightVal);
+    case "-=":
+      return num(leftVal) - num(rightVal);
+    case "*=":
+      return num(leftVal) * num(rightVal);
+    case "/=":
+      return num(leftVal) / num(rightVal);
+    case "%=":
+      return num(leftVal) % num(rightVal);
+    case "**=":
+      return num(leftVal) ** num(rightVal);
+    case "|=":
+      return num(leftVal) | num(rightVal);
+    case "&=":
+      return num(leftVal) & num(rightVal);
+    case "^=":
+      return num(leftVal) ^ num(rightVal);
+    case "<<=":
+      return num(leftVal) << num(rightVal);
+    case ">>=":
+      return num(leftVal) >> num(rightVal);
+    case ">>>=":
+      return num(leftVal) >>> num(rightVal);
+    default:
+      fail("Unsupported assignment op: " + op);
+  }
+}
+
+// src/ast/eval-expression.ts
+function resolveLValue(node, scope, meta) {
+  if (node.type === "Identifier") {
+    assertSafeIdentifier(node.name);
+    return {
+      get: () => getVar(scope, node.name),
+      set: (v) => setVar(scope, node.name, v)
+    };
+  }
+  if (node.type === "MemberExpression") {
+    let obj = evalExpression(node.object, scope);
+    const key = node.computed ? toKey(evalExpression(node.property, scope)) : node.property.name;
+    obj = unwrapRefForMember(obj, key);
+    return {
+      get: () => getMember(obj, key),
+      set: (v) => setMember(obj, key, v)
+    };
+  }
+  fail("Invalid assignment target: " + node.type);
+}
+function evalExpression(node, scope, meta) {
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "Identifier":
+      return unref(getVar(scope, node.name));
+    case "ThisExpression":
+      return void 0;
+    case "ArrayExpression":
+      return node.elements.map(
+        (el) => el ? evalExpression(el, scope) : void 0
+      );
+    case "ObjectExpression": {
+      const out = {};
+      for (const p of node.properties) {
+        if (p.type !== "Property")
+          fail("Unsupported object property: " + p.type);
+        const k = p.computed ? evalExpression(p.key, scope) : p.key.type === "Identifier" ? p.key.name : p.key.value;
+        assertSafeMemberKey(k);
+        out[k] = evalExpression(p.value, scope);
+      }
+      return out;
+    }
+    case "TemplateLiteral": {
+      let s = "";
+      for (let i = 0; i < node.quasis.length; i++) {
+        s += node.quasis[i].value.cooked || "";
+        if (node.expressions[i]) {
+          s += String(evalExpression(node.expressions[i], scope) ?? "");
+        }
+      }
+      return s;
+    }
+    case "ChainExpression":
+      return evalExpression(node.expression, scope);
+    case "MemberExpression": {
+      let obj = evalExpression(node.object, scope);
+      if ((obj == null || obj === void 0) && node.optional) return void 0;
+      const key = node.computed ? toKey(evalExpression(node.property, scope)) : node.property.name;
+      obj = unwrapRefForMember(obj, key);
+      return getMember(obj, key);
+    }
+    case "CallExpression": {
+      const args = [];
+      for (const a of node.arguments) {
+        if (a.type === "SpreadElement") {
+          const spread = evalExpression(a.argument, scope);
+          if (!Array.isArray(spread)) fail("Spread in calls must be an array");
+          args.push(...spread);
+        } else {
+          args.push(evalExpression(a, scope));
+        }
+      }
+      if (node.callee.type === "Identifier") {
+        const name = node.callee.name;
+        assertSafeIdentifier(name);
+        const fn = getVar(scope, name);
+        if (typeof fn !== "function") {
+          if (node.optional) return void 0;
+          return void 0;
+        }
+        return fn.apply(scope.ctx, args);
+      }
+      if (node.callee.type === "MemberExpression") {
+        let obj = evalExpression(node.callee.object, scope);
+        if ((obj == null || obj === void 0) && node.optional) return void 0;
+        const key = node.callee.computed ? toKey(evalExpression(node.callee.property, scope)) : node.callee.property.name;
+        obj = unwrapRefForMember(obj, key);
+        const fn = getMember(obj, key);
+        if (typeof fn !== "function") {
+          if (node.optional) return void 0;
+          return void 0;
+        }
+        return fn.apply(obj, args);
+      }
+      fail("Unsupported call target: " + node.callee.type);
+    }
+    case "ConditionalExpression":
+      return evalExpression(node.test, scope) ? evalExpression(node.consequent, scope) : evalExpression(node.alternate, scope);
+    case "LogicalExpression": {
+      const left = evalExpression(node.left, scope);
+      if (node.operator === "&&")
+        return left && evalExpression(node.right, scope);
+      if (node.operator === "||")
+        return left || evalExpression(node.right, scope);
+      if (node.operator === "??")
+        return left ?? evalExpression(node.right, scope);
+      fail("Unsupported logical op: " + node.operator);
+    }
+    case "BinaryExpression":
+      return evalBinary(
+        node.operator,
+        evalExpression(node.left, scope),
+        evalExpression(node.right, scope)
+      );
+    case "UnaryExpression":
+      return evalUnary(
+        node.operator,
+        evalExpression(node.argument, scope)
+      );
+    case "UpdateExpression": {
+      const lv = resolveLValue(node.argument, scope);
+      const oldVal = lv.get();
+      const n = Number(oldVal);
+      const nextVal = node.operator === "++" ? n + 1 : n - 1;
+      lv.set(nextVal);
+      return node.prefix ? nextVal : oldVal;
+    }
+    case "AssignmentExpression": {
+      const lv = resolveLValue(node.left, scope);
+      const right = evalExpression(node.right, scope);
+      const next = applyAssignment(node.operator, lv.get(), right);
+      lv.set(next);
+      return next;
+    }
+    case "SequenceExpression": {
+      let v;
+      for (const ex of node.expressions) v = evalExpression(ex, scope);
+      return v;
+    }
+    case "ParenthesizedExpression":
+      return evalExpression(node.expression, scope);
+    default:
+      fail("Unsupported expr node: " + node.type);
+  }
+}
+
+// src/ast/eval-expression-async.ts
+async function evalExpressionAsync(node, scope, meta) {
+  if (node?.type === "AwaitExpression") {
+    const v = evalExpression(node.argument, scope);
+    return await Promise.resolve(v);
+  }
+  return evalExpression(node, scope);
+}
+
+// src/ast/flow-control.ts
+var SIG_RETURN = /* @__PURE__ */ Symbol("return");
+var SIG_BREAK = /* @__PURE__ */ Symbol("break");
+var SIG_CONTINUE = /* @__PURE__ */ Symbol("continue");
+function sigReturn(value) {
+  return { t: SIG_RETURN, v: value };
+}
+function sigBreak() {
+  return { t: SIG_BREAK };
+}
+function sigContinue() {
+  return { t: SIG_CONTINUE };
+}
+function isReturn(r) {
+  return r != null && typeof r === "object" && r.t === SIG_RETURN;
+}
+function isBreak(r) {
+  return r != null && typeof r === "object" && r.t === SIG_BREAK;
+}
+function isContinue(r) {
+  return r != null && typeof r === "object" && r.t === SIG_CONTINUE;
+}
+
+// src/ast/exec-statement.ts
+function execSwitch(node, scope, meta) {
+  const discriminant = evalExpression(node.discriminant, scope);
+  let matched = false;
+  for (const caseNode of node.cases) {
+    if (!matched) {
+      if (caseNode.test) {
+        if (evalExpression(caseNode.test, scope) !== discriminant) continue;
+        matched = true;
+      } else {
+        matched = true;
+      }
+    }
+    if (matched) {
+      for (const stmt of caseNode.consequent) {
+        const r = execStatement(stmt, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) return;
+      }
+    }
+  }
+  return;
+}
+function execStatement(node, scope, meta) {
+  switch (node.type) {
+    case "Program": {
+      for (const s of node.body) {
+        const r = execStatement(s, scope, meta);
+        if (isReturn(r)) return r;
+      }
+      return;
+    }
+    case "BlockStatement": {
+      const child = createScope(scope.ctx, Object.create(scope.locals));
+      for (const s of node.body) {
+        const r = execStatement(s, child, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r) || isContinue(r)) return r;
+      }
+      return;
+    }
+    case "ExpressionStatement":
+      return evalExpression(node.expression, scope);
+    case "EmptyStatement":
+      return;
+    case "IfStatement": {
+      const ok = !!evalExpression(node.test, scope);
+      if (ok) return execStatement(node.consequent, scope, meta);
+      if (node.alternate) return execStatement(node.alternate, scope, meta);
+      return;
+    }
+    case "ReturnStatement":
+      return sigReturn(
+        node.argument ? evalExpression(node.argument, scope) : void 0
+      );
+    case "ThrowStatement":
+      throw evalExpression(node.argument, scope);
+    case "BreakStatement":
+      return sigBreak();
+    case "ContinueStatement":
+      return sigContinue();
+    case "SwitchStatement":
+      return execSwitch(node, scope, meta);
+    case "TryStatement": {
+      try {
+        const r = execStatement(node.block, scope, meta);
+        if (isReturn(r)) return r;
+      } catch (err) {
+        if (node.handler) {
+          const child = createScope(scope.ctx, Object.create(scope.locals));
+          const param = node.handler.param;
+          if (param?.type === "Identifier") {
+            assertSafeIdentifier(param.name);
+            child.locals[param.name] = err;
+          }
+          const r = execStatement(node.handler.body, child, meta);
+          if (isReturn(r)) return r;
+        } else {
+          throw err;
+        }
+      } finally {
+        if (node.finalizer) execStatement(node.finalizer, scope, meta);
+      }
+      return;
+    }
+    case "VariableDeclaration": {
+      for (const d of node.declarations) {
+        if (d.id.type !== "Identifier") fail("Only simple var names supported");
+        const name = d.id.name;
+        assertSafeIdentifier(name);
+        scope.locals[name] = d.init ? evalExpression(d.init, scope) : void 0;
+      }
+      return;
+    }
+    case "ForStatement": {
+      if (node.init) {
+        if (node.init.type === "VariableDeclaration") {
+          execStatement(node.init, scope, meta);
+        } else {
+          evalExpression(node.init, scope);
+        }
+      }
+      for (; ; ) {
+        if (node.test && !evalExpression(node.test, scope)) break;
+        const r = execStatement(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) {
+          if (node.update) evalExpression(node.update, scope);
+          continue;
+        }
+        if (node.update) evalExpression(node.update, scope);
+      }
+      return;
+    }
+    case "WhileStatement": {
+      while (evalExpression(node.test, scope)) {
+        const r = execStatement(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      }
+      return;
+    }
+    case "DoWhileStatement": {
+      do {
+        const r = execStatement(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      } while (evalExpression(node.test, scope));
+      return;
+    }
+    case "ForInStatement": {
+      const src = evalExpression(node.right, scope);
+      if (src == null || typeof src !== "object") return;
+      for (const key in src) {
+        if (node.left.type !== "Identifier") {
+          fail("for-in requires Identifier binding");
+        }
+        assertSafeIdentifier(node.left.name);
+        scope.locals[node.left.name] = key;
+        const r = execStatement(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      }
+      return;
+    }
+    case "ForOfStatement": {
+      const src = evalExpression(node.right, scope);
+      if (src == null || typeof src !== "object" || !(Symbol.iterator in Object(src))) {
+        return;
+      }
+      for (const value of src) {
+        if (node.left.type === "Identifier") {
+          assertSafeIdentifier(node.left.name);
+          scope.locals[node.left.name] = value;
+        } else if (node.left.type === "VariableDeclaration") {
+          const d = node.left.declarations[0];
+          if (!d || d.id.type !== "Identifier") fail("for-of requires simple binding");
+          assertSafeIdentifier(d.id.name);
+          scope.locals[d.id.name] = value;
+        } else {
+          fail("for-of requires Identifier or var binding");
+        }
+        const r = execStatement(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      }
+      return;
+    }
+    default:
+      fail("Unsupported stmt node: " + node.type);
+  }
+}
+
+// src/ast/exec-statement-async.ts
+async function execSwitchAsync(node, scope, meta) {
+  const discriminant = await evalExpressionAsync(node.discriminant, scope);
+  let matched = false;
+  for (const caseNode of node.cases) {
+    if (!matched) {
+      if (caseNode.test) {
+        if (await evalExpressionAsync(caseNode.test, scope) !== discriminant) {
+          continue;
+        }
+        matched = true;
+      } else {
+        matched = true;
+      }
+    }
+    if (matched) {
+      for (const stmt of caseNode.consequent) {
+        const r = await execStatementAsync(stmt, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) return;
+      }
+    }
+  }
+  return;
+}
+async function execStatementAsync(node, scope, meta) {
+  switch (node.type) {
+    case "Program": {
+      for (const s of node.body) {
+        const r = await execStatementAsync(s, scope, meta);
+        if (isReturn(r)) return r;
+      }
+      return;
+    }
+    case "BlockStatement": {
+      const child = createScope(scope.ctx, Object.create(scope.locals));
+      for (const s of node.body) {
+        const r = await execStatementAsync(s, child, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r) || isContinue(r)) return r;
+      }
+      return;
+    }
+    case "ExpressionStatement":
+      return await evalExpressionAsync(node.expression, scope);
+    case "EmptyStatement":
+      return;
+    case "IfStatement": {
+      const ok = !!await evalExpressionAsync(node.test, scope);
+      if (ok) return await execStatementAsync(node.consequent, scope, meta);
+      if (node.alternate) return await execStatementAsync(node.alternate, scope, meta);
+      return;
+    }
+    case "ReturnStatement":
+      return sigReturn(
+        node.argument ? await evalExpressionAsync(node.argument, scope) : void 0
+      );
+    case "ThrowStatement":
+      throw await evalExpressionAsync(node.argument, scope);
+    case "BreakStatement":
+      return sigBreak();
+    case "ContinueStatement":
+      return sigContinue();
+    case "SwitchStatement":
+      return await execSwitchAsync(node, scope, meta);
+    case "TryStatement": {
+      try {
+        const r = await execStatementAsync(node.block, scope, meta);
+        if (isReturn(r)) return r;
+      } catch (err) {
+        if (node.handler) {
+          const child = createScope(scope.ctx, Object.create(scope.locals));
+          const param = node.handler.param;
+          if (param?.type === "Identifier") {
+            assertSafeIdentifier(param.name);
+            child.locals[param.name] = err;
+          }
+          const r = await execStatementAsync(node.handler.body, child, meta);
+          if (isReturn(r)) return r;
+        } else {
+          throw err;
+        }
+      } finally {
+        if (node.finalizer) await execStatementAsync(node.finalizer, scope, meta);
+      }
+      return;
+    }
+    case "VariableDeclaration": {
+      for (const d of node.declarations) {
+        if (d.id.type !== "Identifier") fail("Only simple var names supported");
+        const name = d.id.name;
+        assertSafeIdentifier(name);
+        scope.locals[name] = d.init ? await evalExpressionAsync(d.init, scope) : void 0;
+      }
+      return;
+    }
+    case "ForStatement": {
+      if (node.init) {
+        if (node.init.type === "VariableDeclaration") {
+          await execStatementAsync(node.init, scope, meta);
+        } else {
+          await evalExpressionAsync(node.init, scope);
+        }
+      }
+      for (; ; ) {
+        if (node.test && !await evalExpressionAsync(node.test, scope)) break;
+        const r = await execStatementAsync(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) {
+          if (node.update) await evalExpressionAsync(node.update, scope);
+          continue;
+        }
+        if (node.update) await evalExpressionAsync(node.update, scope);
+      }
+      return;
+    }
+    case "WhileStatement": {
+      while (await evalExpressionAsync(node.test, scope)) {
+        const r = await execStatementAsync(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      }
+      return;
+    }
+    case "DoWhileStatement": {
+      do {
+        const r = await execStatementAsync(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      } while (await evalExpressionAsync(node.test, scope));
+      return;
+    }
+    case "ForInStatement": {
+      const src = await evalExpressionAsync(node.right, scope);
+      if (src == null || typeof src !== "object") return;
+      for (const key in src) {
+        if (node.left.type !== "Identifier") fail("for-in requires Identifier binding");
+        assertSafeIdentifier(node.left.name);
+        scope.locals[node.left.name] = key;
+        const r = await execStatementAsync(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      }
+      return;
+    }
+    case "ForOfStatement": {
+      const src = await evalExpressionAsync(node.right, scope);
+      if (src == null || typeof src !== "object" || !(Symbol.iterator in Object(src))) {
+        return;
+      }
+      for (const value of src) {
+        if (node.left.type === "Identifier") {
+          assertSafeIdentifier(node.left.name);
+          scope.locals[node.left.name] = value;
+        } else if (node.left.type === "VariableDeclaration") {
+          const d = node.left.declarations[0];
+          if (!d || d.id.type !== "Identifier") fail("for-of requires simple binding");
+          assertSafeIdentifier(d.id.name);
+          scope.locals[d.id.name] = value;
+        } else {
+          fail("for-of requires Identifier or var binding");
+        }
+        const r = await execStatementAsync(node.body, scope, meta);
+        if (isReturn(r)) return r;
+        if (isBreak(r)) break;
+        if (isContinue(r)) continue;
+      }
+      return;
+    }
+    default:
+      fail("Unsupported stmt node: " + node.type);
+  }
+}
+
+// src/ast/context-eval.ts
+function evalInCtxAst(ast, ctx, $event, $el, debugLabel = "") {
+  try {
+    const locals = /* @__PURE__ */ Object.create(null);
+    locals.$event = $event;
+    locals.$el = $el;
+    const scope = createScope(ctx, locals);
+    return evalExpression(ast, scope, { debugLabel });
+  } catch (err) {
+    logError(WarnCodes.AST_EVAL, err, {
+      label: debugLabel || "expression"
+    });
+    return void 0;
+  }
+}
+function runInCtxAst(programAst, ctx, $event, $el, debugLabel = "") {
+  try {
+    const locals = /* @__PURE__ */ Object.create(null);
+    locals.$event = $event;
+    locals.$el = $el;
+    const scope = createScope(ctx, locals);
+    const r = execStatement(programAst, scope, { debugLabel });
+    return r && r.t === SIG_RETURN ? r.v : r;
+  } catch (err) {
+    logError(WarnCodes.AST_STMT, err, {
+      label: debugLabel || "statement"
+    });
+    return void 0;
+  }
+}
+async function runInCtxAstAsync(programAst, ctx, $event, $el, debugLabel = "") {
+  try {
+    const locals = /* @__PURE__ */ Object.create(null);
+    locals.$event = $event;
+    locals.$el = $el;
+    const scope = createScope(ctx, locals);
+    const r = await execStatementAsync(programAst, scope, {
+      debugLabel
+    });
+    return r && r.t === SIG_RETURN ? r.v : r;
+  } catch (err) {
+    logError(WarnCodes.AST_STMT, err, {
+      label: debugLabel || "statement"
+    });
+    return void 0;
+  }
+}
+
+// src/runtime/registry.ts
+function skyNode(node) {
+  return node;
+}
+function register(node, fn) {
+  (skyNode(node).__skyCleanup ??= []).push(fn);
+}
+function cleanup(node) {
+  skyNode(node).__skyCleanup?.forEach((fn) => fn());
+  if (node.childNodes) Array.from(node.childNodes).forEach(cleanup);
+}
+function autoEffect(node, fn) {
+  const runner = effect(fn);
+  register(node, () => runner.stop());
+  return runner;
+}
+
+// src/runtime/normalize.ts
+function normalizeClass(val) {
+  if (!val) return "";
+  if (typeof val === "string") return val;
+  if (Array.isArray(val))
+    return val.filter(Boolean).map(normalizeClass).join(" ");
+  if (typeof val === "object")
+    return Object.keys(val).filter((k) => val[k]).join(" ");
+  return "";
+}
+function normalizeStyle(val) {
+  if (!val) return {};
+  if (typeof val === "string") return val;
+  if (typeof val === "object") return val;
+  return {};
+}
+function isTextInputLike(el) {
+  return el.nodeType === 1 && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT");
+}
+function isCustomElement(el) {
+  return el.tagName.includes("-");
+}
+function deepTrack(val, seen = /* @__PURE__ */ new Set()) {
+  val = unref(val);
+  if (!val || typeof val !== "object" || seen.has(val)) return;
+  seen.add(val);
+  if (Array.isArray(val)) {
+    val.length;
+    for (let i = 0; i < val.length; i++) deepTrack(val[i], seen);
+  } else {
+    const record = val;
+    for (const k in record) deepTrack(record[k], seen);
+  }
+}
+function cloneShallow(val) {
+  val = unref(val);
+  if (Array.isArray(val)) return val.slice();
+  if (val && typeof val === "object") return { ...val };
+  return val;
+}
+
+// src/runtime/text-template.ts
+function compileTextTemplate(raw) {
+  const tokens = [];
+  let last = 0;
+  raw.replace(/{{(.*?)}}/g, (m, expr, idx) => {
+    if (idx > last) tokens.push({ t: "text", v: raw.slice(last, idx) });
+    tokens.push({ t: "expr", ast: compileExpr(expr) });
+    last = idx + m.length;
+    return m;
+  });
+  if (last < raw.length) tokens.push({ t: "text", v: raw.slice(last) });
+  return function render(ctx, $el) {
+    let out = "";
+    for (const tok of tokens) {
+      if (tok.t === "text") out += tok.v;
+      else {
+        const v = evalInCtxAst(tok.ast, ctx, void 0, $el, "text");
+        out += v == null ? "" : String(v);
+      }
+    }
+    return out;
+  };
+}
+
+// src/runtime/for-utils.ts
+function kebabToCamel(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function parseForAlias(lhsRaw) {
+  const lhs = (lhsRaw || "").trim();
+  const tuple = lhs.match(
+    /^\(\s*([A-Za-z_$][\w$]*)\s*,\s*([A-Za-z_$][\w$]*)\s*\)$/
+  );
+  if (tuple) return { item: tuple[1], index: tuple[2] };
+  const single = lhs.match(/^([A-Za-z_$][\w$]*)$/);
+  if (single) return { item: single[1], index: null };
+  throw new Error(
+    "sky-for syntax error. Use `item in items` or `(item, index) in items`"
+  );
+}
+function normalizeForSource(source, indexAlias) {
+  if (source === null || source === void 0) {
+    return [];
+  }
+  if (Array.isArray(source)) {
+    return source.map((value, index) => ({
+      value,
+      key: index,
+      extra: indexAlias ? { [indexAlias]: index } : {}
+    }));
+  }
+  if (typeof source === "number" && !Number.isNaN(source)) {
+    const items = [];
+    const n = Math.floor(Math.abs(source));
+    for (let i = 0; i < n; i++) {
+      items.push({
+        value: i,
+        key: i,
+        extra: indexAlias ? { [indexAlias]: i } : {}
+      });
+    }
+    return items;
+  }
+  if (typeof source === "string") {
+    return Array.from(source).map((char, index) => ({
+      value: char,
+      key: index,
+      extra: indexAlias ? { [indexAlias]: index } : {}
+    }));
+  }
+  if (typeof source === "object") {
+    const record = source;
+    const keys = Object.keys(record);
+    return keys.map((key, index) => ({
+      value: record[key],
+      key,
+      extra: {
+        $key: key,
+        ...indexAlias ? { [indexAlias]: index } : {}
+      }
+    }));
+  }
+  return [
+    {
+      value: source,
+      key: 0,
+      extra: indexAlias ? { [indexAlias]: 0 } : {}
+    }
+  ];
+}
+
+// src/runtime/prop-map.ts
+var PROP_NAME_CACHE = /* @__PURE__ */ new WeakMap();
+function buildPropMapFor(el) {
+  const map = /* @__PURE__ */ new Map();
+  let proto = el;
+  while (proto && proto !== Object.prototype) {
+    for (const k of Object.getOwnPropertyNames(proto)) {
+      map.set(k.toLowerCase(), k);
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return map;
+}
+function resolveDomPropName(el, raw) {
+  if (raw.includes("-")) return kebabToCamel(raw);
+  const lower = raw.toLowerCase();
+  let map = PROP_NAME_CACHE.get(el.constructor);
+  if (!map) {
+    map = buildPropMapFor(el);
+    PROP_NAME_CACHE.set(el.constructor, map);
+  }
+  return map.get(lower) ?? raw;
+}
+
+// src/runtime/dom.ts
+var NODE_ELEMENT = 1;
+var NODE_TEXT = 3;
+function isElement(node) {
+  return node.nodeType === NODE_ELEMENT;
+}
+function isTextNode(node) {
+  return node.nodeType === NODE_TEXT;
+}
+function asHtmlEl(node) {
+  return node;
+}
+function tagName(el) {
+  return el.tagName.toUpperCase();
+}
+function inputType(el) {
+  return (el.getAttribute("type") || "text").toLowerCase();
+}
+function inputField(el) {
+  return el;
+}
+function createComment(ref2, data) {
+  const doc = ref2.ownerDocument;
+  if (!doc) {
+    throw new Error("[Sky] Node has no ownerDocument");
+  }
+  return doc.createComment(data);
+}
+
+// src/runtime/model-parse.ts
+var SKY_MODEL_MODIFIERS = /* @__PURE__ */ new Set(["lazy", "number", "trim"]);
+function unknownModifierSegments(parts) {
+  return parts.filter((p) => !SKY_MODEL_MODIFIERS.has(p));
+}
+function parseSkyModelAttr(attrName, value) {
+  const key = value.trim();
+  if (!key || !/^[A-Za-z_$][\w$]*$/.test(key)) {
+    return null;
+  }
+  if (attrName === "sky-model") {
+    return { key, arg: null, modifiers: [], unknownModifiers: [] };
+  }
+  let rest = null;
+  if (attrName.startsWith("sky-model:")) {
+    rest = attrName.slice("sky-model:".length);
+  } else if (attrName.startsWith("sky-model.")) {
+    rest = attrName.slice("sky-model.".length);
+  } else {
+    return null;
+  }
+  if (!rest) {
+    return { key, arg: null, modifiers: [], unknownModifiers: [] };
+  }
+  const parts = rest.split(".").filter((p) => p.length > 0);
+  if (parts.length === 0) {
+    return { key, arg: null, modifiers: [], unknownModifiers: [] };
+  }
+  const first = parts[0];
+  if (SKY_MODEL_MODIFIERS.has(first)) {
+    return {
+      key,
+      arg: null,
+      modifiers: normalizeSkyModelModifiers(parts),
+      unknownModifiers: unknownModifierSegments(parts)
+    };
+  }
+  return {
+    key,
+    arg: first,
+    modifiers: normalizeSkyModelModifiers(parts.slice(1)),
+    unknownModifiers: unknownModifierSegments(parts.slice(1))
+  };
+}
+function isSkyModelAttr(attrName) {
+  return attrName === "sky-model" || attrName.startsWith("sky-model.") || attrName.startsWith("sky-model:");
+}
+function normalizeSkyModelModifiers(modifiers) {
+  const out = [];
+  for (const m of modifiers) {
+    if (SKY_MODEL_MODIFIERS.has(m) && !out.includes(m)) {
+      out.push(m);
+    }
+  }
+  return out;
+}
+function coerceModelWriteValue(value, modifiers) {
+  const mods = normalizeSkyModelModifiers(modifiers);
+  let v = value;
+  if (mods.includes("trim") && typeof v === "string") {
+    v = v.trim();
+  }
+  if (mods.includes("number")) {
+    if (v === "" || v == null) {
+      return "";
+    }
+    const n = typeof v === "number" ? v : Number(v);
+    return Number.isNaN(n) ? v : n;
+  }
+  return v;
+}
+function coerceModelPropValue(value, modifiers) {
+  const v = value == null ? void 0 : value;
+  const mods = normalizeSkyModelModifiers(modifiers);
+  if (mods.includes("number") && v !== "" && v != null) {
+    const n = typeof v === "number" ? v : Number(v);
+    return Number.isNaN(n) ? v : n;
+  }
+  return v;
+}
+
+// src/runtime/model.ts
+function bindSkyModel(el, ctx, key, modifiers = []) {
+  const mods = normalizeSkyModelModifiers(modifiers);
+  const field = inputField(el);
+  const tag = tagName(el);
+  const type = inputType(el);
+  if (tag === "INPUT" && type === "checkbox") {
+    return {
+      event: "change",
+      read: () => {
+        field.checked = Boolean(unref(ctx[key]));
+      }
+    };
+  }
+  if (tag === "INPUT" && type === "radio") {
+    return {
+      event: "change",
+      read: () => {
+        const v = unref(ctx[key]);
+        field.checked = field.value === String(v ?? "");
+      }
+    };
+  }
+  if (tag === "SELECT") {
+    return {
+      event: "change",
+      read: () => {
+        const v = unref(ctx[key]);
+        field.value = v == null ? "" : String(v);
+      }
+    };
+  }
+  if (tag === "INPUT" || tag === "TEXTAREA") {
+    const event = mods.includes("lazy") ? "change" : "input";
+    return {
+      event,
+      read: () => {
+        const v = unref(ctx[key]);
+        const str = v == null ? "" : String(v);
+        if (field.value !== str) field.value = str;
+      }
+    };
+  }
+  return { event: "input", read: () => {
+  } };
+}
+function readModelValue(el) {
+  const field = inputField(el);
+  if (tagName(el) === "INPUT" && inputType(el) === "checkbox") return field.checked;
+  if (tagName(el) === "INPUT" && inputType(el) === "radio") return field.value;
+  if (tagName(el) === "SELECT") return field.value;
+  if (tagName(el) === "INPUT" || tagName(el) === "TEXTAREA") return field.value;
+  return void 0;
+}
+function writeModelValue(ctx, key, el, value, modifiers = []) {
+  const field = inputField(el);
+  if (tagName(el) === "INPUT" && inputType(el) === "radio" && !field.checked) {
+    return;
+  }
+  const coerced = coerceModelWriteValue(value, modifiers);
+  const cur = ctx[key];
+  if (isRef(cur)) cur.value = coerced;
+  else ctx[key] = coerced;
+}
+
+// src/runtime/model-custom.ts
+function resolveModelPropAndEvent(el, arg) {
+  const prop = arg ? resolveDomPropName(el, arg) : "modelValue";
+  return { prop, eventName: `update:${prop}` };
+}
+function bindCustomSkyModel(el, ctx, key, arg, modifiers = []) {
+  const mods = normalizeSkyModelModifiers(modifiers);
+  const { prop, eventName } = resolveModelPropAndEvent(el, arg);
+  const target = el;
+  const read = () => {
+    target[prop] = coerceModelPropValue(unref(ctx[key]), mods);
+  };
+  const onUpdate = (e) => {
+    const ce = e;
+    let val = ce.detail;
+    if (val === void 0 && e.target) {
+      val = e.target[prop];
+    }
+    writeModelValue(ctx, key, el, val, mods);
+  };
+  return { prop, eventName, read, onUpdate };
+}
+
+// src/runtime/events.ts
+var DOM_EVENT_MODS = /* @__PURE__ */ new Set([
+  "prevent",
+  "stop",
+  "self",
+  "once",
+  "exact",
+  "capture",
+  "passive",
+  "ctrl",
+  "alt",
+  "shift",
+  "meta"
+]);
+var WRAP_MODS = DOM_EVENT_MODS;
+function getListenerOptions(modifiers) {
+  const opts = {};
+  if (modifiers.includes("capture")) opts.capture = true;
+  if (modifiers.includes("passive")) opts.passive = true;
+  return Object.keys(opts).length > 0 ? opts : false;
+}
+var KEY_ALIAS = {
+  enter: "Enter",
+  tab: "Tab",
+  delete: "Delete",
+  del: "Delete",
+  esc: "Escape",
+  escape: "Escape",
+  space: " ",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight"
+};
+function isKeyLikeModifier(mod) {
+  if (WRAP_MODS.has(mod)) return false;
+  return mod.length >= 1;
+}
+function getKeyModifiers(modifiers) {
+  return modifiers.filter(isKeyLikeModifier);
+}
+var KNOWN_EVENT_MODIFIERS = /* @__PURE__ */ new Set([
+  ...DOM_EVENT_MODS,
+  ...Object.keys(KEY_ALIAS),
+  "ctrl",
+  "alt",
+  "shift",
+  "meta"
+]);
+function getUnknownEventModifiers(modifiers) {
+  return modifiers.filter((m) => {
+    if (KNOWN_EVENT_MODIFIERS.has(m)) return false;
+    if (/^[a-z]$/i.test(m)) return false;
+    return true;
+  });
+}
+function systemModifierActive(e, mod) {
+  switch (mod) {
+    case "ctrl":
+      return e.ctrlKey;
+    case "alt":
+      return e.altKey;
+    case "shift":
+      return e.shiftKey;
+    case "meta":
+      return e.metaKey;
+    default:
+      return false;
+  }
+}
+function keyModifierMatches(e, mod) {
+  if (["ctrl", "alt", "shift", "meta"].includes(mod)) {
+    return systemModifierActive(e, mod);
+  }
+  const lower = mod.toLowerCase();
+  const want = KEY_ALIAS[lower] ?? mod;
+  if (e.key === want) return true;
+  if (e.code === want) return true;
+  if (want.length === 1 && e.key.toLowerCase() === want.toLowerCase()) return true;
+  if (/^[a-z]$/i.test(want) && e.code === `Key${want.toUpperCase()}`) return true;
+  return false;
+}
+function parseOnEventAttr(attrName) {
+  if (!attrName.startsWith("on") || attrName.length <= 2) return null;
+  const event = attrName.slice(2);
+  return { event, modifiers: [], code: "" };
+}
+function parseAtEventAttr(attrName, code) {
+  if (!attrName.startsWith("@")) return null;
+  const parts = attrName.slice(1).split(".");
+  const event = parts[0];
+  if (!event) return null;
+  return { event, modifiers: parts.slice(1), code };
+}
+function wrapEventHandler(handler, modifiers, node) {
+  let wrapped = handler;
+  if (modifiers.includes("once")) {
+    wrapped = /* @__PURE__ */ ((fn) => {
+      let called = false;
+      return (e) => {
+        if (called) return;
+        called = true;
+        fn(e);
+      };
+    })(wrapped);
+  }
+  const keyMods = getKeyModifiers(modifiers);
+  return (e) => {
+    if (modifiers.includes("self") && e.target !== node) return;
+    if (modifiers.includes("exact")) {
+      if (e.target !== node) return;
+      if (e instanceof MouseEvent && e.button !== 0) return;
+    }
+    if (keyMods.length > 0 && "key" in e) {
+      const ke = e;
+      for (const mod of keyMods) {
+        if (!keyModifierMatches(ke, mod)) return;
+      }
+    }
+    if (modifiers.includes("prevent")) e.preventDefault();
+    if (modifiers.includes("stop")) e.stopPropagation();
+    wrapped(e);
+  };
+}
+
+// src/runtime/compile-mode.ts
+var mode = "client";
+function getCompileMode() {
+  return mode;
+}
+function runInCompileMode(next, fn) {
+  const prev = mode;
+  mode = next;
+  try {
+    return fn();
+  } finally {
+    mode = prev;
+  }
+}
+
+// src/runtime/compile-node.ts
+function warnUnknownEventModifiers(node, binding, label) {
+  for (const mod of getUnknownEventModifiers(binding.modifiers)) {
+    warnOnce(
+      WarnCodes.EVENT_UNKNOWN_MODIFIER,
+      { mod, event: binding.event },
+      { element: node, label }
+    );
+  }
+}
+function runHandler(code, ctx, node, label, e) {
+  const program = compileStmt(code);
+  const handlerUsesAwait = /\bawait\b/.test(code);
+  if (handlerUsesAwait) {
+    void runInCtxAstAsync(program, ctx, e, node, label).catch(
+      (err) => logError(WarnCodes.HANDLER_RUNTIME, err, { element: node, label })
+    );
+  } else {
+    runInCtxAst(program, ctx, e, node, label);
+  }
+}
+function compileTextNode(node, ctx) {
+  const raw = node.nodeValue ?? "";
+  if (!raw.includes("{{")) return;
+  const render = compileTextTemplate(raw);
+  bindReactive(node, () => {
+    node.nodeValue = render(ctx, node.parentElement);
+  });
+}
+function compileChildren(parent, ctx) {
+  for (const child of Array.from(parent.childNodes)) {
+    if (isTextNode(child)) {
+      compileTextNode(child, ctx);
+    } else if (isElement(child)) {
+      compileNode(child, ctx);
+    }
+  }
+}
+function bindReactive(node, fn, opts) {
+  if (getCompileMode() === "ssr") {
+    fn();
+    return;
+  }
+  if (isElement(node) && node.hasAttribute("sky-once")) {
+    if (isElement(node)) node.removeAttribute("sky-once");
+    const runner = effect(() => {
+      fn();
+      runner.stop();
+    });
+    register(node, () => runner.stop());
+    return;
+  }
+  autoEffect(node, fn);
+}
+function compileNode(node, ctx) {
+  if (!isElement(node)) return;
+  const IF_ATTRS = ["sky-if", "v-if", "w-if"];
+  const ELSEIF_ATTRS = ["sky-else-if", "v-else-if", "w-else-if"];
+  const ELSE_ATTRS = ["sky-else", "v-else", "w-else"];
+  const hasAnyAttr = (el, names) => names.some((n) => el.hasAttribute(n));
+  const getAnyAttr = (el, names) => {
+    for (const n of names)
+      if (el.hasAttribute(n)) return el.getAttribute(n) || "";
+    return "";
+  };
+  const removeAnyAttr = (el, names) => names.forEach((n) => el.removeAttribute(n));
+  const nextUsefulSibling = (n) => {
+    let cur = n;
+    while (cur) {
+      if (cur.nodeType === 8) {
+        cur = cur.nextSibling;
+        continue;
+      }
+      if (cur.nodeType === 3 && !(cur.nodeValue ?? "").trim()) {
+        cur = cur.nextSibling;
+        continue;
+      }
+      return cur;
+    }
+    return null;
+  };
+  if (hasAnyAttr(node, IF_ATTRS)) {
+    const parent = node.parentNode;
+    if (!parent) return;
+    const anchor = createComment(node, "if-chain");
+    parent.insertBefore(anchor, node);
+    const chain = [];
+    let cur = node;
+    while (cur) {
+      cur = nextUsefulSibling(cur);
+      if (!cur || cur.nodeType !== 1) break;
+      const elCur = cur;
+      const isIf = hasAnyAttr(elCur, IF_ATTRS);
+      const isElseIf = hasAnyAttr(elCur, ELSEIF_ATTRS);
+      const isElse = hasAnyAttr(elCur, ELSE_ATTRS);
+      if (!isIf && !isElseIf && !isElse) break;
+      if (chain.length > 0 && isIf) break;
+      if (chain.length === 0 && !isIf) break;
+      if (chain.length > 0 && chain[chain.length - 1].isElse) break;
+      const expStr = isElse ? "" : getAnyAttr(elCur, IF_ATTRS) || getAnyAttr(elCur, ELSEIF_ATTRS);
+      const expAst = expStr ? compileExpr(expStr) : null;
+      const tpl = elCur.cloneNode(true);
+      if (isElement(tpl)) {
+        removeAnyAttr(tpl, IF_ATTRS);
+        removeAnyAttr(tpl, ELSEIF_ATTRS);
+        removeAnyAttr(tpl, ELSE_ATTRS);
+      }
+      chain.push({ isElse: !!isElse, expAst, tpl });
+      const next = elCur.nextSibling;
+      elCur.remove();
+      cur = next;
+    }
+    let activeEl = null;
+    bindReactive(anchor, () => {
+      let matched = false;
+      for (const item of chain) {
+        const ok = !matched && (item.isElse || item.expAst != null && !!evalInCtxAst(item.expAst, ctx, void 0, anchor, "if"));
+        if (!ok) continue;
+        matched = true;
+        if (!activeEl || activeEl.__skyIfTpl !== item.tpl) {
+          if (activeEl) {
+            cleanup(activeEl);
+            activeEl.remove();
+            activeEl = null;
+          }
+          const el = item.tpl.cloneNode(true);
+          el.__skyIfTpl = item.tpl;
+          parent.insertBefore(el, anchor.nextSibling);
+          compileTree(el, ctx);
+          activeEl = el;
+        }
+        break;
+      }
+      if (!matched && activeEl) {
+        cleanup(activeEl);
+        activeEl.remove();
+        activeEl = null;
+      }
+    });
+    return;
+  }
+  if (node.hasAttribute("sky-for")) {
+    const exp = node.getAttribute("sky-for") || "";
+    const keyExp = node.getAttribute("sky-key");
+    const parts = exp.split(/\s+in\s+/);
+    const lhs = parts[0] || "";
+    const rhs = parts.slice(1).join(" in ") || "";
+    let alias;
+    let indexAlias;
+    try {
+      ({ item: alias, index: indexAlias } = parseForAlias(lhs));
+    } catch {
+      warn(
+        WarnCodes.FOR_INVALID_SYNTAX,
+        { expr: exp },
+        { element: node, label: "sky-for" }
+      );
+      return;
+    }
+    const listAst = compileExpr(rhs.trim());
+    const keyAst = keyExp ? compileExpr(keyExp) : null;
+    if (!keyAst && getCompileMode() !== "ssr") {
+      warnOnce(WarnCodes.FOR_KEY_RECOMMENDED, {}, { element: node, label: "sky-for" });
+    }
+    const parent = node.parentNode;
+    if (!parent) return;
+    const anchor = createComment(node, "sky-for");
+    parent.replaceChild(anchor, node);
+    const template = node.cloneNode(true);
+    template.removeAttribute("sky-for");
+    template.removeAttribute("sky-key");
+    const blocks = /* @__PURE__ */ new Map();
+    const runList = () => {
+      const sourceValue = evalInCtxAst(listAst, ctx, void 0, anchor, "for");
+      const items = normalizeForSource(sourceValue, indexAlias);
+      const used = /* @__PURE__ */ new Set();
+      const listParent = anchor.parentNode;
+      if (!listParent) return;
+      let insertBefore = anchor.nextSibling;
+      for (let idx = 0; idx < items.length; idx++) {
+        const item = items[idx];
+        if (!item) continue;
+        const itemValue = item.value;
+        const extra = item.extra;
+        let blockKey;
+        if (keyAst) {
+          const keyCtx = Object.create(ctx);
+          keyCtx[alias] = itemValue;
+          keyCtx.$item = itemValue;
+          keyCtx.$index = idx;
+          if (indexAlias) keyCtx[indexAlias] = idx;
+          Object.assign(keyCtx, extra);
+          blockKey = evalInCtxAst(keyAst, keyCtx, void 0, anchor, "for:key");
+        } else {
+          blockKey = item.key;
+        }
+        let block = blocks.get(blockKey);
+        if (!block) {
+          const el = template.cloneNode(true);
+          const rowCtx = Object.create(ctx);
+          rowCtx[alias] = itemValue;
+          rowCtx.$item = itemValue;
+          rowCtx.$index = idx;
+          if (indexAlias) rowCtx[indexAlias] = idx;
+          Object.assign(rowCtx, extra);
+          compileTree(el, rowCtx);
+          block = { el, ctx: rowCtx };
+          blocks.set(blockKey, block);
+        } else {
+          block.ctx[alias] = itemValue;
+          block.ctx.$item = itemValue;
+          block.ctx.$index = idx;
+          if (indexAlias) block.ctx[indexAlias] = idx;
+          Object.assign(block.ctx, extra);
+        }
+        if (block.el.parentNode !== listParent || block.el.nextSibling !== insertBefore) {
+          listParent.insertBefore(block.el, insertBefore);
+        }
+        insertBefore = block.el.nextSibling;
+        used.add(blockKey);
+      }
+      blocks.forEach((block, k) => {
+        if (!used.has(k)) {
+          if (getCompileMode() !== "ssr") cleanup(block.el);
+          block.el.parentNode?.removeChild(block.el);
+          blocks.delete(k);
+        }
+      });
+    };
+    if (getCompileMode() === "ssr") {
+      runList();
+    } else {
+      autoEffect(anchor, runList);
+    }
+    return;
+  }
+  if (node.hasAttribute("sky-ref")) {
+    const k = node.getAttribute("sky-ref");
+    if (!k) return;
+    node.removeAttribute("sky-ref");
+    const slot = ctx[k];
+    if (isRef(slot)) slot.value = node;
+    else ctx[k] = ref(node);
+    register(node, () => {
+      const cur = ctx[k];
+      if (isRef(cur)) cur.value = null;
+    });
+  }
+  if (node.hasAttribute("sky-show")) {
+    const exp = node.getAttribute("sky-show") || "";
+    node.removeAttribute("sky-show");
+    const expAst = compileExpr(exp);
+    const html = asHtmlEl(node);
+    bindReactive(node, () => {
+      html.style.display = evalInCtxAst(expAst, ctx, void 0, node, "show") ? "" : "none";
+    });
+  }
+  if (node.hasAttribute("sky-html")) {
+    warnOnce(WarnCodes.SKY_HTML_UNSAFE, {}, { element: node, label: "sky-html" });
+    const exp = node.getAttribute("sky-html") || "";
+    node.removeAttribute("sky-html");
+    const expAst = compileExpr(exp);
+    const htmlEl = asHtmlEl(node);
+    bindReactive(node, () => {
+      const val = evalInCtxAst(expAst, ctx, void 0, node, "html");
+      htmlEl.innerHTML = val == null ? "" : String(val);
+    });
+  }
+  const attrs = Array.from(node.attributes);
+  const modelAttrs = attrs.filter((a) => isSkyModelAttr(a.name));
+  if (modelAttrs.length > 1) {
+    warnOnce(WarnCodes.MODEL_DUPLICATE, {}, { element: node });
+  }
+  const modelAttr = modelAttrs[0];
+  if (modelAttr) {
+    const binding = parseSkyModelAttr(modelAttr.name, modelAttr.value);
+    if (!binding) {
+      warn(
+        WarnCodes.MODEL_INVALID_KEY,
+        { value: modelAttr.value },
+        { element: node, label: modelAttr.name }
+      );
+    } else {
+      node.removeAttribute(modelAttr.name);
+      const { key, arg, modifiers, unknownModifiers } = binding;
+      if (unknownModifiers.length > 0) {
+        warnOnce(
+          WarnCodes.MODEL_UNKNOWN_MODIFIER,
+          { mods: unknownModifiers.join(".") },
+          { element: node, label: modelAttr.name }
+        );
+      }
+      if (isCustomElement(node)) {
+        const custom = bindCustomSkyModel(node, ctx, key, arg, modifiers);
+        bindReactive(node, () => custom.read());
+        node.addEventListener(custom.eventName, custom.onUpdate);
+        register(
+          node,
+          () => node.removeEventListener(custom.eventName, custom.onUpdate)
+        );
+      } else {
+        if (arg != null) {
+          warn(
+            WarnCodes.MODEL_ARG_ON_NATIVE,
+            { arg, tag: node.tagName.toLowerCase(), key },
+            { element: node, label: modelAttr.name }
+          );
+        }
+        const model = bindSkyModel(node, ctx, key, modifiers);
+        bindReactive(node, () => model.read());
+        const h = () => writeModelValue(ctx, key, node, readModelValue(node), modifiers);
+        node.addEventListener(model.event, h);
+        register(node, () => node.removeEventListener(model.event, h));
+      }
+    }
+  }
+  const isOnAttr = (name) => name.startsWith("on") && name.length > 2;
+  for (const a of attrs) {
+    const attrName = a.name;
+    const code = a.value;
+    if (isOnAttr(attrName)) {
+      const binding = parseOnEventAttr(attrName);
+      if (!binding) continue;
+      node.removeAttribute(attrName);
+      warnUnknownEventModifiers(node, binding, `on${binding.event}`);
+      const opts = getListenerOptions(binding.modifiers);
+      const handler = wrapEventHandler(
+        (e) => runHandler(code, ctx, node, `on${binding.event}`, e),
+        binding.modifiers,
+        node
+      );
+      node.addEventListener(binding.event, handler, opts);
+      register(node, () => node.removeEventListener(binding.event, handler, opts));
+      continue;
+    }
+    if (attrName.startsWith("@")) {
+      const binding = parseAtEventAttr(attrName, code);
+      if (!binding) continue;
+      node.removeAttribute(attrName);
+      warnUnknownEventModifiers(node, binding, `@${binding.event}`);
+      const opts = getListenerOptions(binding.modifiers);
+      const handler = wrapEventHandler(
+        (e) => runHandler(code, ctx, node, `@${binding.event}`, e),
+        binding.modifiers,
+        node
+      );
+      node.addEventListener(binding.event, handler, opts);
+      register(node, () => node.removeEventListener(binding.event, handler, opts));
+      continue;
+    }
+    if (attrName === ":class" || attrName === "sky-bind:class") {
+      node.removeAttribute(attrName);
+      const expAst = compileExpr(code);
+      const html = asHtmlEl(node);
+      const base = html.dataset.baseClass ?? (html.dataset.baseClass = html.className);
+      bindReactive(node, () => {
+        const val = evalInCtxAst(expAst, ctx, void 0, node, "class");
+        const cls = normalizeClass(val);
+        html.className = base + (cls ? " " + cls : "");
+      });
+      continue;
+    }
+    if (attrName === ":style" || attrName === "sky-bind:style") {
+      node.removeAttribute(attrName);
+      const expAst = compileExpr(code);
+      const html = asHtmlEl(node);
+      bindReactive(node, () => {
+        const val = normalizeStyle(
+          evalInCtxAst(expAst, ctx, void 0, node, "style")
+        );
+        if (typeof val === "string") html.style.cssText = val;
+        else {
+          const styleObj = val;
+          for (const k of Object.keys(styleObj)) {
+            html.style.setProperty(k, String(styleObj[k]));
+          }
+        }
+      });
+      continue;
+    }
+    if (attrName.startsWith("sky-bind:") && attrName !== "sky-bind:class" && attrName !== "sky-bind:style") {
+      node.removeAttribute(attrName);
+      let prop = attrName.split(":")[1] ?? "";
+      prop = resolveDomPropName(node, prop);
+      const expAst = compileExpr(code);
+      if (prop === "value" && isTextInputLike(node)) {
+        bindReactive(node, () => {
+          const v = evalInCtxAst(expAst, ctx, void 0, node, "bind:value");
+          const str = v == null ? "" : String(v);
+          if (typeof document !== "undefined" && document.activeElement === node)
+            return;
+          if (node.value !== str) node.value = str;
+        });
+      } else {
+        bindReactive(node, () => {
+          let v = evalInCtxAst(expAst, ctx, void 0, node, `bind:${prop}`);
+          if (isCustomElement(node) && (Array.isArray(v) || v && typeof v === "object")) {
+            deepTrack(v);
+            v = cloneShallow(v);
+          }
+          node[prop] = v;
+        });
+      }
+      continue;
+    }
+  }
+  compileChildren(node, ctx);
+}
+function compileTree(root, ctx) {
+  if (isElement(root)) {
+    compileNode(root, ctx);
+    return;
+  }
+  compileChildren(root, ctx);
+}
+
+// src/runtime/mount.ts
+function mount(root, ctx) {
+  compileTree(root, ctx);
+  return ctx;
+}
+
+// src/runtime/context.ts
+function createCtx(exposed = {}) {
+  const ctx = reactive({});
+  if (exposed && typeof exposed === "object") Object.assign(ctx, exposed);
+  return ctx;
+}
+
+// src/runtime/app.ts
+function createReactivity(setup) {
+  return {
+    mount(target, initial = {}) {
+      const root = typeof target === "string" ? document.querySelector(target) : target;
+      if (!root) {
+        const targetLabel = typeof target === "string" ? target : "<element>";
+        warn(WarnCodes.MOUNT_TARGET_NOT_FOUND, { target: targetLabel });
+        throw new Error(getWarnMessage(WarnCodes.MOUNT_TARGET_NOT_FOUND, { target: targetLabel }));
+      }
+      const scope = effectScope(true);
+      return scope.run(() => {
+        const exposed = (typeof setup === "function" ? setup() : setup) || {};
+        const ctx = createCtx({ ...initial, ...exposed });
+        mount(root, ctx);
+        return {
+          ctx,
+          unmount() {
+            cleanup(root);
+            scope.stop();
+            clearAstCaches();
+          }
+        };
+      });
+    }
+  };
+}
+
+// src/ssr/document.ts
+async function parseSSRDocument(markup) {
+  if (typeof DOMParser !== "undefined") {
+    const doc = new DOMParser().parseFromString(markup, "text/html");
+    return doc;
+  }
+  try {
+    const { parseHTML } = await import('linkedom');
+    const { document: document2 } = parseHTML(markup);
+    return document2;
+  } catch {
+    throw new Error(
+      "[Sky SSR] No DOM available. Use in a browser or install optional peer `linkedom`."
+    );
+  }
+}
+
+// src/ssr/strip-anchors.ts
+var ANCHOR_MARKERS = /* @__PURE__ */ new Set(["sky-for", "if-chain"]);
+function stripCompilerCommentAnchors(root) {
+  const comments = [];
+  const walk = (node) => {
+    for (const child of Array.from(node.childNodes)) {
+      if (child.nodeType === 8) {
+        const data = child.data.trim();
+        if (ANCHOR_MARKERS.has(data)) comments.push(child);
+      } else if (child.nodeType === 1) {
+        walk(child);
+      }
+    }
+  };
+  walk(root);
+  for (const c of comments) {
+    c.parentNode?.removeChild(c);
+  }
+}
+
+// src/ssr/render.ts
+async function renderToString(markup, ctx, options = {}) {
+  const doc = await parseSSRDocument(markup);
+  const root = options.root != null ? doc.querySelector(options.root) : doc.body;
+  if (!root) {
+    const rootSel = options.root ?? "body";
+    warn(WarnCodes.SSR_ROOT_NOT_FOUND, { root: rootSel });
+    throw new Error(getWarnMessage(WarnCodes.SSR_ROOT_NOT_FOUND, { root: rootSel }));
+  }
+  const scope = { ...options.initial, ...ctx };
+  const reactiveCtx = createCtx(scope);
+  runInCompileMode("ssr", () => {
+    compileTree(root, reactiveCtx);
+  });
+  const stripAnchors = options.stripAnchors !== false;
+  if (stripAnchors) {
+    stripCompilerCommentAnchors(root);
+    if (options.fullDocument && doc.documentElement) {
+      stripCompilerCommentAnchors(doc.documentElement);
+    }
+  }
+  if (options.fullDocument) {
+    return doc.documentElement.outerHTML;
+  }
+  return root.nodeType === 1 ? root.outerHTML : String(root);
+}
+
+// src/runtime/handler-runner.ts
+async function runHandlerCode(code, ctx, $event = null, $el = null) {
+  const program = compileStmt(code);
+  if (/\bawait\b/.test(code)) {
+    return runInCtxAstAsync(program, ctx, $event, $el, "handler");
+  }
+  return runInCtxAst(program, ctx, $event, $el, "handler");
+}
+
+export { EffectScope, WarnCodes, skyDevSnapshot as __SKY_DEV__, computed, createReactivity, customRef, effect, effectScope, flushSync, getCurrentScope, getSkyDev, isReactive, isReadonly, isRef, logError, markRaw, mount, nextTick, onScopeDispose, parseSSRDocument, reactive, readonly, ref, renderToString, resetWarned, runHandlerCode, setSkyDev, setWarnHandler, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, warn, warnOnce, watch, watchEffect };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map