@lark.js/mvc 0.0.1

package/dist/index.js

@@ -0,0 +1,5030 @@
+// src/constants.ts
+var globalCounter = 0;
+var SPLITTER = "";
+var ROUTER_EVENTS = {
+  CHANGE: "change",
+  CHANGED: "changed",
+  PAGE_UNLOAD: "page_unload"
+};
+var TAG_KEY = "lark-key";
+var TAG_ATTR_KEY = "lark-attr-key";
+var TAG_VIEW_KEY = "lark-view-key";
+var LARK_VIEW = "lark-view";
+var EVT_METHOD_REG = new RegExp(
+  `(?:([\\w-]+)${SPLITTER})?([^(]+)\\(([\\s\\S]*?)?\\)`
+);
+var VIEW_EVT_METHOD_REG = /^(\$?)([\w]*)<(.*?)>(?:<([\w ,]*)>)?$/;
+var URL_TRIM_HASH_REGEX = /(?:^.*\/\/[^/]+|#.*$)/gi;
+var URL_TRIM_QUERY_REGEX = /^[^#]*#?!?/;
+var URL_PARAM_REGEX = /([^=&?/#]+)=?([^&#?]*)/g;
+var URL_QUERY_HASH_REGEX = /[#?].*$/;
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATH_NS = "http://www.w3.org/1998/Math/MathML";
+var TAG_NAME_REGEX = /<([a-z][^/\0>\x20\t\r\n\f]+)/i;
+var CALL_BREAK_TIME = 48;
+function nextCounter() {
+  return ++globalCounter;
+}
+
+// src/utils.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) return true;
+  return proto === Object.prototype || proto === null;
+}
+var isArray = Array.isArray;
+function isPrimitiveOrFunc(value) {
+  return !value || typeof value !== "object" && typeof value !== "function";
+}
+function isPrimitive(value) {
+  return !value || typeof value !== "object";
+}
+var _localCounter = 0;
+function generateId(prefix) {
+  return (prefix || "lark_") + _localCounter++;
+}
+function syncCounter(val) {
+  _localCounter = val;
+}
+function noop() {
+}
+function has(owner, prop) {
+  return owner != null && Object.prototype.hasOwnProperty.call(owner, prop);
+}
+function keys(obj) {
+  const result = [];
+  for (const p in obj) {
+    if (has(obj, p)) {
+      result.push(p);
+    }
+  }
+  return result;
+}
+function assign(target, ...sources) {
+  for (const source of sources) {
+    if (source) {
+      for (const p in source) {
+        if (has(source, p)) {
+          target[p] = source[p];
+        }
+      }
+    }
+  }
+  return target;
+}
+function funcWithTry(fns, args, context, configError) {
+  const fnArray = isArray(fns) ? fns : [fns];
+  let ret;
+  for (const fn of fnArray) {
+    try {
+      ret = Function.prototype.apply.call(fn, context, args);
+    } catch (e) {
+      configError(e);
+    }
+  }
+  return ret;
+}
+function setData(newData, oldData, changedKeys2, excludes) {
+  let changed = false;
+  for (const p in newData) {
+    if (has(newData, p)) {
+      const now2 = newData[p];
+      const old = oldData[p];
+      if ((!isPrimitiveOrFunc(now2) || old !== now2) && !excludes.has(p)) {
+        changedKeys2[p] = 1;
+        changed = true;
+      }
+      oldData[p] = now2;
+    }
+  }
+  return changed;
+}
+function translateData(data, value) {
+  if (isPrimitive(value)) {
+    const prop = String(value);
+    if (prop[0] === SPLITTER && has(data, prop)) {
+      return data[prop];
+    }
+    return value;
+  }
+  if (isPlainObject(value) || isArray(value)) {
+    for (const p in value) {
+      if (has(value, p)) {
+        const val = value[p];
+        const newVal = translateData(data, val);
+        value[p] = newVal;
+      }
+    }
+    return value;
+  }
+  return value;
+}
+function getById(id) {
+  if (!id) return null;
+  if (typeof id === "object") return id;
+  return document.getElementById(id);
+}
+function getAttribute(element, attr) {
+  return Element.prototype.getAttribute.call(element, attr) ?? "";
+}
+function ensureElementId(element) {
+  const id = element.getAttribute("id");
+  if (id) return id;
+  element.autoId = 1;
+  const newId = generateId();
+  element.id = newId;
+  return newId;
+}
+function nodeInside(a, b) {
+  const aNode = typeof a === "string" ? document.getElementById(a) : a;
+  const bNode = typeof b === "string" ? document.getElementById(b) : b;
+  if (!aNode || !bNode) return false;
+  if (aNode === bNode) return true;
+  try {
+    return (bNode.compareDocumentPosition(aNode) & 16) === 16;
+  } catch {
+    return false;
+  }
+}
+var paramsTemp = {};
+function paramsReplacer(_match, name, value) {
+  try {
+    paramsTemp[name] = decodeURIComponent(value || "");
+  } catch {
+    paramsTemp[name] = value || "";
+  }
+  return "";
+}
+function parseUri(uri) {
+  paramsTemp = {};
+  const path = uri.replace(URL_QUERY_HASH_REGEX, "");
+  const pathname = path;
+  const actualPath = uri === pathname && IS_URL_PARAMS.test(pathname) ? "" : pathname;
+  uri.replace(actualPath, "").replace(URL_PARAM_REGEX, paramsReplacer);
+  return {
+    path: actualPath,
+    params: { ...paramsTemp }
+  };
+}
+var IS_URL_PARAMS = {
+  test(s) {
+    return /(?!^)=|&/.test(s);
+  }
+};
+function toUri(path, params, keepEmptyObject) {
+  const pairs = [];
+  let hasParams = false;
+  for (const p in params) {
+    if (has(params, p)) {
+      const v = String(params[p] ?? "");
+      if (!keepEmptyObject || v || has(keepEmptyObject, p)) {
+        pairs.push(`${p}=${encodeURIComponent(v)}`);
+        hasParams = true;
+      }
+    }
+  }
+  if (hasParams) {
+    path += (path && (~path.indexOf("?") ? "&" : "?")) + pairs.join("&");
+  }
+  return path;
+}
+function toMap(list, key) {
+  const map = {};
+  if (!list) return map;
+  for (const item of list) {
+    const mapKey = key ? String(item[key]) : String(item);
+    map[mapKey] = key ? item : (map[mapKey] || 0) + 1;
+  }
+  return map;
+}
+function now() {
+  return Date.now ? Date.now() : (/* @__PURE__ */ new Date()).getTime();
+}
+function classExtend(ctor, base, props, statics) {
+  const baseProto = base["prototype"] ?? {};
+  const cProto = Object.create(baseProto);
+  assign(cProto, props);
+  Object.assign(ctor, statics);
+  cProto.constructor = ctor;
+  ctor["prototype"] = cProto;
+}
+
+// src/apply-style.ts
+var injectedStyleIds = /* @__PURE__ */ new Set();
+function applyStyle(styleIdOrPairs, css) {
+  if (Array.isArray(styleIdOrPairs)) {
+    if (styleIdOrPairs.length % 2 !== 0) {
+      throw new Error("Invalid array of [id, content] pairs");
+    }
+    const cleanupCallbacks = [];
+    for (let i = 0; i < styleIdOrPairs.length; i += 2) {
+      const styleId = styleIdOrPairs[i];
+      const styleContent = styleIdOrPairs[i + 1];
+      const cleanup = applyStyle(styleId, styleContent);
+      if (cleanup !== noop) {
+        cleanupCallbacks.push(cleanup);
+      }
+    }
+    return () => {
+      for (const cleanup of cleanupCallbacks) {
+        cleanup();
+      }
+    };
+  }
+  if (css && !injectedStyleIds.has(styleIdOrPairs)) {
+    injectedStyleIds.add(styleIdOrPairs);
+    const styleElement = document.createElement("style");
+    styleElement.setAttribute("from", "lark");
+    styleElement.id = styleIdOrPairs;
+    styleElement.textContent = css;
+    document.head.append(styleElement);
+    return () => {
+      injectedStyleIds.delete(styleIdOrPairs);
+      styleElement.remove();
+    };
+  }
+  return noop;
+}
+
+// src/mark.ts
+var DELETED_KEY = SPLITTER + "$a";
+var MARK_OBJECT_KEY = SPLITTER + "$b";
+function mark(host, key) {
+  let sign = 0;
+  const hostRecord = host;
+  if (!hostRecord[DELETED_KEY]) {
+    const markHost = hostRecord[MARK_OBJECT_KEY] || (hostRecord[MARK_OBJECT_KEY] = {});
+    if (!Object.prototype.hasOwnProperty.call(markHost, key)) {
+      markHost[key] = 0;
+    }
+    sign = ++markHost[key];
+  }
+  return () => {
+    const temp = hostRecord[MARK_OBJECT_KEY];
+    return !!(temp && sign === temp[key]);
+  };
+}
+function unmark(host) {
+  const hostRecord = host;
+  hostRecord[MARK_OBJECT_KEY] = 0;
+  hostRecord[DELETED_KEY] = 1;
+}
+
+// src/safeguard.ts
+var proxiesPool = /* @__PURE__ */ new Map();
+var SAFEGUARD_SENTINEL = "_sf_";
+function safeguard(data, getter, setter, isRoot) {
+  if (typeof window.__lark_debug === "undefined" || !window.__lark_debug) {
+    return data;
+  }
+  if (typeof Proxy === "undefined") {
+    return data;
+  }
+  if (isPrimitive(data)) {
+    return data;
+  }
+  const build = (prefix, obj) => {
+    const cacheKey = (getter || "") + "
" + (setter || "");
+    const cached = proxiesPool.get(obj);
+    if (cached && cached.cacheKey === cacheKey) {
+      return cached.entity;
+    }
+    if (Reflect.get(obj, SAFEGUARD_SENTINEL)) {
+      return obj;
+    }
+    const entity = new Proxy(obj, {
+      set(target, property, value) {
+        if (!setter && !prefix) {
+          throw new Error(
+            "Avoid write back, key: " + prefix + property + " value:" + value + " more: https://github.com/hangtiancheng/h"
+          );
+        }
+        Reflect.set(target, property, value);
+        if (setter) {
+          setter(prefix + property, value);
+        }
+        return true;
+      },
+      get(target, property) {
+        if (property === SAFEGUARD_SENTINEL) {
+          return true;
+        }
+        const out = Reflect.get(target, property);
+        if (!prefix && getter) {
+          getter(property);
+        }
+        if (!isRoot && has(target, property) && (isArray(out) || isPlainObject(out))) {
+          return build(prefix + property + ".", out);
+        }
+        return out;
+      }
+    });
+    proxiesPool.set(obj, { cacheKey, entity });
+    return entity;
+  };
+  return build("", data);
+}
+
+// src/cache.ts
+function sortCacheEntries(a, b) {
+  return b.frequency - a.frequency || b.lastTimestamp - a.lastTimestamp;
+}
+var Cache = class {
+  /** Cache entries array */
+  entries = [];
+  /** Fast lookup: prefixed key -> entry */
+  lookup = /* @__PURE__ */ new Map();
+  /** Buffer size for eviction */
+  bufferSize;
+  /** Maximum cache size */
+  maxSize;
+  /** Total capacity (maxSize + bufferSize) */
+  capacity;
+  /** Callback when entry is removed */
+  onRemove;
+  /** Sort comparator */
+  comparator;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 20;
+    this.bufferSize = options.bufferSize ?? 5;
+    this.capacity = this.maxSize + this.bufferSize;
+    this.onRemove = options.onRemove;
+    this.comparator = options.sortComparator ?? sortCacheEntries;
+  }
+  /** Prefix a key with SPLITTER for namespace isolation */
+  prefixKey(key) {
+    return SPLITTER + key;
+  }
+  /**
+   * Get a cached value by key.
+   * Updates frequency and timestamp for cache sorting.
+   */
+  get(key) {
+    const prefixedKey = this.prefixKey(key);
+    const entry = this.lookup.get(prefixedKey);
+    if (!entry) return void 0;
+    entry.frequency++;
+    entry.lastTimestamp = nextCounter();
+    return entry.value;
+  }
+  /**
+   * Iterate all cached values.
+   */
+  forEach(callback) {
+    for (const entry of this.entries) {
+      callback(entry.value);
+    }
+  }
+  /**
+   * Set or update a cached value.
+   * If key already exists, updates value and increments frequency.
+   * If cache exceeds capacity, triggers eviction.
+   */
+  set(key, value) {
+    const prefixedKey = this.prefixKey(key);
+    const existing = this.lookup.get(prefixedKey);
+    if (existing) {
+      existing.value = value;
+      existing.frequency++;
+      existing.lastTimestamp = nextCounter();
+      return;
+    }
+    if (this.entries.length >= this.capacity) {
+      this.evictEntries();
+    }
+    const entry = {
+      originalKey: key,
+      value,
+      frequency: 1,
+      lastTimestamp: nextCounter()
+    };
+    this.entries.push(entry);
+    this.lookup.set(prefixedKey, entry);
+  }
+  /**
+   * Delete a cached entry.
+   */
+  del(key) {
+    const prefixedKey = this.prefixKey(key);
+    const entry = this.lookup.get(prefixedKey);
+    if (!entry) return;
+    entry.frequency = -1;
+    entry.value = void 0;
+    this.lookup.delete(prefixedKey);
+    if (this.onRemove) {
+      this.onRemove(key);
+    }
+  }
+  /**
+   * Check if a key exists in cache.
+   */
+  has(key) {
+    return this.lookup.has(this.prefixKey(key));
+  }
+  /** Get current cache size */
+  get size() {
+    return this.entries.length;
+  }
+  /** Clear all entries */
+  clear() {
+    if (this.onRemove) {
+      for (const entry of this.entries) {
+        this.onRemove(entry.originalKey);
+      }
+    }
+    this.entries = [];
+    this.lookup.clear();
+  }
+  /** Evict least-used entries from cache */
+  evictEntries() {
+    this.entries.sort(this.comparator);
+    let count = this.bufferSize;
+    while (count-- > 0 && this.entries.length > 0) {
+      const entry = this.entries.pop();
+      if (entry && entry.frequency > 0) {
+        this.lookup.delete(this.prefixKey(entry.originalKey));
+        if (this.onRemove) {
+          this.onRemove(entry.originalKey);
+        }
+      }
+    }
+    this.entries = this.entries.filter((e) => e.frequency !== -1);
+  }
+};
+
+// src/event-emitter.ts
+var EventEmitter = class {
+  /** Event listeners: prefixed key -> listener array */
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Bind event listener.
+   */
+  on(event, handler) {
+    const key = SPLITTER + event;
+    let list = this.listeners.get(key);
+    if (!list) {
+      list = [];
+      this.listeners.set(key, list);
+    }
+    list.push({ handler, executing: 0 });
+    return this;
+  }
+  /**
+   * Unbind event listener.
+   * If handler is provided, removes only that handler.
+   * If no handler, removes all handlers for the event.
+   */
+  off(event, handler) {
+    const key = SPLITTER + event;
+    if (handler) {
+      const list = this.listeners.get(key);
+      if (list) {
+        for (const listener of list) {
+          if (listener.handler === handler) {
+            listener.handler = noop;
+            break;
+          }
+        }
+      }
+    } else {
+      this.listeners.delete(key);
+      Reflect.deleteProperty(this, `on${event}`);
+    }
+    return this;
+  }
+  /**
+   * Fire event, execute all bound handlers.
+   * Supports executing state management: handlers removed during
+   * execution are safely handled.
+   *
+   * @param event - Event name
+   * @param data - Event data (type property added automatically)
+   * @param remove - Whether to remove all handlers after firing
+   * @param lastToFirst - Whether to execute handlers in reverse order
+   */
+  fire(event, data, remove, lastToFirst) {
+    const key = SPLITTER + event;
+    const list = this.listeners.get(key);
+    if (!data) {
+      data = {};
+    }
+    data["type"] = event;
+    if (list) {
+      let end = list.length;
+      const len = end - 1;
+      while (end--) {
+        const idx = lastToFirst ? end : len - end;
+        const listener = list[idx];
+        if (listener.handler !== noop) {
+          listener.executing = 1;
+          funcWithTry(
+            [listener.handler],
+            [data],
+            this,
+            noop
+          );
+          listener.executing = "";
+        } else if (!listener.executing) {
+          list.splice(idx, 1);
+        }
+      }
+    }
+    const onMethodName = `on${event}`;
+    const onMethod = this[onMethodName];
+    if (typeof onMethod === "function") {
+      funcWithTry(
+        [onMethod],
+        [data],
+        this,
+        noop
+      );
+    }
+    if (remove) {
+      this.off(event);
+    }
+    return this;
+  }
+};
+
+// src/state.ts
+var appData = {};
+var keyRefCounts = {};
+var changedKeys = {};
+var stashedChangedKeys = {};
+var dataIsChanged = false;
+var dataWhereSet = {};
+var emitter = new EventEmitter();
+var booted = false;
+function markBooted() {
+  booted = true;
+}
+function setupKeysRef(keys2) {
+  const keyList = keys2.split(",");
+  for (const key of keyList) {
+    if (has(keyRefCounts, key)) {
+      keyRefCounts[key]++;
+    } else {
+      keyRefCounts[key] = 1;
+    }
+  }
+  return keyList;
+}
+function teardownKeysRef(keyList) {
+  for (const key of keyList) {
+    if (has(keyRefCounts, key)) {
+      const count = --keyRefCounts[key];
+      if (count <= 0) {
+        Reflect.deleteProperty(keyRefCounts, key);
+        Reflect.deleteProperty(appData, key);
+        if (typeof window.__lark_debug !== "undefined" && window.__lark_debug) {
+          Reflect.deleteProperty(dataWhereSet, key);
+        }
+      }
+    }
+  }
+}
+var notifyStarted = 0;
+var notifyList = [];
+var notifyTimer;
+function clearNotify(key) {
+  for (let i = notifyList.length; i--; ) {
+    if (notifyList[i]?.key === key) {
+      notifyList.splice(i, 1);
+    }
+  }
+}
+function doNotify() {
+  const locker = {};
+  for (const n of notifyList) {
+    if (!locker[n.key]) {
+      console.warn(n.message);
+      locker[n.key] = 1;
+    }
+  }
+  notifyList.length = 0;
+  notifyStarted = 0;
+}
+function delayNotify(key, message) {
+  clearTimeout(notifyTimer);
+  notifyStarted = 0;
+  notifyList.push({ key, message });
+  if (!notifyStarted) {
+    notifyStarted = 1;
+    notifyTimer = setTimeout(doNotify, 500);
+  }
+}
+var State = {
+  /**
+   * Get data from state.
+   */
+  get(key) {
+    const result = key ? appData[key] : appData;
+    if (typeof window.__lark_debug !== "undefined" && window.__lark_debug) {
+      return safeguard(
+        result,
+        (dataKey) => {
+          if (booted && has(dataWhereSet, dataKey) && dataWhereSet[dataKey] !== window.location.pathname) {
+            console.warn(
+              `beware! You get state:"{State}.${dataKey}" where it set by page:${dataWhereSet[dataKey]}`
+            );
+          }
+        },
+        (path, _value) => {
+          const sub = key || path;
+          delayNotify(
+            sub,
+            `beware! You direct modify "{State}.${sub}" You should call State.set() and State.digest() to notify other views`
+          );
+        }
+      );
+    }
+    return result;
+  },
+  /**
+   * Set data to state.
+   */
+  set(data, excludes) {
+    dataIsChanged = setData(data, appData, changedKeys, excludes || /* @__PURE__ */ new Set()) || dataIsChanged;
+    if (typeof window.__lark_debug !== "undefined" && window.__lark_debug && booted) {
+      for (const p in data) {
+        dataWhereSet[p] = window.location.pathname;
+      }
+    }
+    return State;
+  },
+  /**
+   * Detect data changes and fire changed event if any.
+   */
+  digest(data, excludes) {
+    if (data) {
+      State.set(data, excludes);
+    }
+    if (dataIsChanged) {
+      if (typeof window.__lark_debug !== "undefined" && window.__lark_debug) {
+        for (const p in changedKeys) {
+          if (has(changedKeys, p)) {
+            clearNotify(p);
+          }
+        }
+      }
+      dataIsChanged = false;
+      const keys2 = {};
+      for (const k in changedKeys) {
+        if (has(changedKeys, k)) {
+          keys2[k] = 1;
+        }
+      }
+      stashedChangedKeys = keys2;
+      changedKeys = {};
+      emitter.fire(ROUTER_EVENTS.CHANGED, { keys: keys2 });
+    }
+  },
+  /**
+   * Get diff of what changed in last digest.
+   */
+  diff() {
+    return stashedChangedKeys;
+  },
+  /**
+   * Create mixin to clean up state keys on view destroy.
+   * Must be used in view.mixins array.
+   */
+  clean(keys2) {
+    return {
+      ctor: function() {
+        const keyList = setupKeysRef(keys2);
+        this.on("destroy", () => {
+          teardownKeysRef(keyList);
+        });
+      }
+    };
+  },
+  /**
+   * Bind event listener.
+   */
+  on(event, handler) {
+    emitter.on(event, handler);
+    return State;
+  },
+  /**
+   * Unbind event listener.
+   */
+  off(event, handler) {
+    emitter.off(event, handler);
+    return State;
+  },
+  /**
+   * Fire event.
+   */
+  fire(event, data, remove) {
+    emitter.fire(event, data, remove);
+    return State;
+  }
+};
+
+// src/router.ts
+var emitter2 = new EventEmitter();
+var hrefCache = new Cache();
+var changedCache = new Cache();
+var lastLocation = createEmptyLocation();
+var lastChanged;
+var silent = 0;
+var booted2 = false;
+var cachedRoutes;
+var cachedUnmatchedView;
+var cachedDefaultView;
+var cachedDefaultPath;
+var cachedRewrite;
+var defaultTitle;
+var frameworkConfig;
+function createEmptyLocation() {
+  return {
+    href: "",
+    srcQuery: "",
+    srcHash: "",
+    query: { path: "", params: {} },
+    hash: { path: "", params: {} },
+    params: {},
+    get: (_key, defaultValue) => defaultValue ?? ""
+  };
+}
+function getParam(key, defaultValue) {
+  return this["params"][key] || (defaultValue !== void 0 ? defaultValue : "");
+}
+function attachViewAndPath(loc) {
+  if (!frameworkConfig) return;
+  if (!cachedRoutes) {
+    cachedRoutes = frameworkConfig.routes || {};
+    cachedUnmatchedView = frameworkConfig.unmatchedView;
+    cachedDefaultView = frameworkConfig.defaultView;
+    cachedDefaultPath = frameworkConfig.defaultPath || "/";
+    cachedRewrite = frameworkConfig.rewrite;
+  }
+  if (!loc.view) {
+    let path = loc.hash["path"] || cachedDefaultPath || "/";
+    if (cachedRewrite) {
+      path = cachedRewrite(
+        path,
+        loc["params"],
+        cachedRoutes
+      );
+    }
+    const viewEntry = cachedRoutes[path] || cachedUnmatchedView || cachedDefaultView;
+    loc["path"] = path;
+    loc.view = typeof viewEntry === "string" ? viewEntry : viewEntry?.view || "";
+    if (typeof viewEntry === "object" && viewEntry) {
+      assign(loc, viewEntry);
+    }
+  }
+}
+function getChanged(oldLoc, newLoc) {
+  const oKey = oldLoc.href;
+  const nKey = newLoc.href;
+  const tKey = oKey + SPLITTER + nKey;
+  const cached = changedCache.get(tKey);
+  if (cached) {
+    return cached;
+  }
+  let hasChanged = false;
+  const changedParams = {};
+  const setDiff = (key, oldVal, newVal) => {
+    const from = oldVal || "";
+    const to = newVal || "";
+    if (from !== to) {
+      changedParams[key] = { from, to };
+      hasChanged = true;
+    }
+  };
+  const allParamKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(oldLoc["params"]),
+    ...Object.keys(newLoc["params"])
+  ]);
+  for (const key of allParamKeys) {
+    setDiff(key, oldLoc["params"][key], newLoc["params"][key]);
+  }
+  const result = {
+    ["params"]: changedParams,
+    force: !oKey,
+    changed: hasChanged
+  };
+  setDiff("path", oldLoc["path"], newLoc["path"]);
+  if (changedParams["path"]) {
+    result["path"] = changedParams["path"];
+    hasChanged = true;
+    result.changed = true;
+  }
+  const viewKey = "view";
+  setDiff(viewKey, oldLoc.view, newLoc.view);
+  if (changedParams[viewKey]) {
+    result.view = changedParams[viewKey];
+    hasChanged = true;
+    result.changed = true;
+  }
+  const finalResult = {
+    changed: hasChanged,
+    diff: result
+  };
+  changedCache.set(tKey, finalResult);
+  return finalResult;
+}
+function updateHash(path, replace) {
+  const hashbang = frameworkConfig?.hashbang || "#!";
+  const fullPath = path === "" ? "" : hashbang + path;
+  if (replace) {
+    window.location.replace(fullPath);
+  } else {
+    window.location.hash = fullPath;
+  }
+}
+function updateUrl(path, params, loc, replace, silentFlag, lQuery) {
+  path = toUri(path, params, lQuery);
+  if (path !== loc.srcHash) {
+    silent = silentFlag ? 1 : 0;
+    updateHash(path, replace);
+  }
+}
+var Router = {
+  /**
+   * Parse href into Location object.
+   * Defaults to window.location.href.
+   */
+  parse(href) {
+    href = href || window.location.href;
+    const cached = hrefCache.get(href);
+    if (cached) {
+      return cached;
+    }
+    const srcQuery = href.replace(URL_TRIM_HASH_REGEX, "");
+    const srcHash = href.replace(URL_TRIM_QUERY_REGEX, "");
+    const query = parseUri(srcQuery);
+    const hash = parseUri(srcHash);
+    const params = assign({}, query["params"], hash["params"]);
+    const location = {
+      href,
+      srcQuery,
+      srcHash,
+      query: { path: query.path, params: query["params"] },
+      hash: { path: hash.path, params: hash["params"] },
+      ["params"]: params,
+      get: getParam
+    };
+    if (booted2) {
+      attachViewAndPath(location);
+      hrefCache.set(href, location);
+    }
+    if (typeof window.__lark_debug !== "undefined" && window.__lark_debug) {
+      location["params"] = safeguard(location["params"]);
+    }
+    return location;
+  },
+  /**
+   * Compute diff between current and previous location.
+   * Fires 'changed' event if location changed and not silent.
+   */
+  diff() {
+    const location = Router.parse();
+    const changed = getChanged(lastLocation, location);
+    lastLocation = location;
+    if (!silent && changed.changed) {
+      lastChanged = changed.diff;
+      if (lastChanged["path"]) {
+        document.title = defaultTitle || document.title;
+      }
+      emitter2.fire(
+        ROUTER_EVENTS.CHANGED,
+        lastChanged
+      );
+    }
+    silent = 0;
+    if (typeof window.__lark_debug !== "undefined" && window.__lark_debug && lastChanged) {
+      lastChanged = safeguard(lastChanged);
+    }
+    return lastChanged;
+  },
+  /**
+   * Navigate to new URL.
+   *
+   * @param pathOrParams - Path string or params object
+   * @param params - Query parameters (if pathOrParams is string)
+   * @param replace - Whether to replace current history entry
+   * @param silentFlag - Whether to silently update without firing events
+   */
+  to(pathOrParams, params, replace, silentFlag) {
+    let tPath = "";
+    let tParams;
+    if (!params && typeof pathOrParams === "object") {
+      tParams = pathOrParams;
+    } else {
+      const parsed = parseUri(pathOrParams);
+      tPath = parsed.path;
+      tParams = { ...parsed["params"] };
+      if (params) {
+        assign(tParams, params);
+      }
+    }
+    const lPath = lastLocation["path"] || "";
+    const lParams = lastLocation["params"];
+    const lQuery = {};
+    for (const k in lastLocation.query["params"]) {
+      if (has(lastLocation.query["params"], k)) {
+        lQuery[k] = 1;
+      }
+    }
+    if (tPath) {
+      if (!has(window, "history")) {
+        for (const qKey in lQuery) {
+          if (has(lQuery, qKey) && !has(tParams, qKey)) {
+            tParams[qKey] = "";
+          }
+        }
+      }
+    } else if (lParams) {
+      tPath = lPath;
+      tParams = assign({}, lParams, tParams);
+    }
+    updateUrl(
+      tPath,
+      tParams,
+      lastLocation,
+      replace,
+      silentFlag,
+      lQuery
+    );
+  },
+  /**
+   * Join multiple path segments into a single path.
+   */
+  join(...paths) {
+    let result = paths.join("/");
+    result = result.replace(/\/\.\//g, "/");
+    const doubleDotRegex = /\/[^/]+\/\.\.\//;
+    while (doubleDotRegex.test(result)) {
+      result = result.replace(doubleDotRegex, "/");
+    }
+    result = result.replace(/\/{2,}/g, "/");
+    return result;
+  },
+  /** Bind event listener */
+  on(event, handler) {
+    emitter2.on(event, handler);
+    return Router;
+  },
+  /** Unbind event listener */
+  off(event, handler) {
+    emitter2.off(event, handler);
+    return Router;
+  },
+  /** Fire event */
+  fire(event, data, remove) {
+    emitter2.fire(event, data, remove);
+    return Router;
+  },
+  /**
+   * Internal: bind hashchange and beforeunload events.
+   * Called by Framework.boot().
+   */
+  _bind() {
+    defaultTitle = document.title;
+    let lastHash = Router.parse().srcHash;
+    let suspend;
+    const watchChange = () => {
+      if (suspend) {
+        return;
+      }
+      const loc = Router.parse();
+      const newHash = loc.srcHash;
+      if (newHash !== lastHash) {
+        const changeEvent = {
+          p: 0,
+          reject: () => {
+            changeEvent.p = 1;
+            suspend = "";
+            updateHash(lastHash);
+          },
+          resolve: () => {
+            changeEvent.p = 1;
+            lastHash = newHash;
+            suspend = "";
+            updateHash(newHash);
+            Router.diff();
+          },
+          prevent: () => {
+            suspend = 1;
+          }
+        };
+        Router.fire(
+          ROUTER_EVENTS.CHANGE,
+          changeEvent
+        );
+        if (!suspend && !changeEvent.p) {
+          changeEvent.resolve();
+        }
+      }
+    };
+    Router.notify = watchChange;
+    window.addEventListener("hashchange", watchChange);
+    window.addEventListener("popstate", watchChange);
+    window.addEventListener("beforeunload", (domEvent) => {
+      const te = {};
+      Router.fire(ROUTER_EVENTS.PAGE_UNLOAD, te);
+      const msg = te["msg"];
+      if (msg) {
+        domEvent.returnValue = msg;
+      }
+    });
+    Router.diff();
+  },
+  /**
+   * Internal: set framework config for route resolution.
+   */
+  _setConfig(cfg) {
+    frameworkConfig = cfg;
+  }
+};
+function markRouterBooted() {
+  booted2 = true;
+}
+
+// src/event-delegator.ts
+var rootEvents = {};
+var selectorEvents = {};
+var rangeEvents = {};
+var rangeFrames = {};
+var elementGuid = 0;
+var eventInfoCache = new Cache({
+  maxSize: 30,
+  bufferSize: 10
+});
+var frameGetter;
+function parseEventInfo(eventInfo) {
+  const cached = eventInfoCache.get(eventInfo);
+  if (cached) {
+    return assign({}, cached, { r: eventInfo });
+  }
+  const match = eventInfo.match(EVT_METHOD_REG) || [];
+  const result = {
+    v: match[1] || "",
+    n: match[2] || "",
+    i: match[3] || ""
+  };
+  eventInfoCache.set(eventInfo, result);
+  return assign({}, result, { r: eventInfo });
+}
+function findFrameInfo(current, eventType) {
+  const eventInfos = [];
+  let begin = current;
+  const info = current.getAttribute(`lark-${eventType}`);
+  let match;
+  if (info) {
+    match = parseEventInfo(info);
+  }
+  if (match && !match.v || selectorEvents[eventType]) {
+    let selectorFrameId = "#";
+    let backtrace = 0;
+    while (begin && begin !== document.body) {
+      const beginId = begin.id;
+      if (beginId && frameGetter?.(beginId)) {
+        selectorFrameId = beginId;
+        break;
+      }
+      begin = begin.parentElement;
+    }
+    const currentId = current.id;
+    if (currentId && frameGetter?.(currentId)) {
+      backtrace = 1;
+      selectorFrameId = currentId;
+    }
+    let frameId = selectorFrameId;
+    do {
+      const frame = frameId ? frameGetter?.(frameId) : void 0;
+      if (frame) {
+        const view = frame.view;
+        if (view) {
+          const selectorEntry = view.eventSelectorMap[eventType];
+          if (selectorEntry) {
+            for (const selectorName of selectorEntry.selectors) {
+              const entry = {
+                r: selectorName,
+                v: frameId,
+                n: selectorName,
+                i: ""
+              };
+              if (selectorName) {
+                if (!backtrace && elementMatchesSelector(current, selectorName)) {
+                  eventInfos.push(entry);
+                }
+              } else if (backtrace) {
+                eventInfos.unshift(entry);
+              }
+            }
+          }
+          if (view.tmpl && !backtrace) {
+            if (match && !match.v) {
+              match.v = frameId;
+            }
+            break;
+          }
+          backtrace = 0;
+        }
+      }
+      if (frame) {
+        frameId = frame.parentId || "";
+      } else {
+        break;
+      }
+    } while (frameId);
+  }
+  if (match) {
+    eventInfos.push({
+      v: match.v,
+      r: match.r,
+      n: match.n,
+      i: match.i
+    });
+  }
+  return eventInfos;
+}
+function elementMatchesSelector(element, selector) {
+  try {
+    return element.matches?.(selector) ?? false;
+  } catch {
+    return false;
+  }
+}
+function domEventProcessor(domEvent) {
+  const target = domEvent.target;
+  const eventType = domEvent.type;
+  let lastFrameId = "";
+  let current = target;
+  while (current && current !== document.body) {
+    const eventInfos = findFrameInfo(current, eventType);
+    if (eventInfos.length) {
+      for (const info of eventInfos) {
+        const { v: frameId, n: handlerName, i: params } = info;
+        if (lastFrameId !== frameId) {
+          if (lastFrameId && domEvent.isPropagationStopped?.()) {
+            break;
+          }
+          lastFrameId = frameId;
+        }
+        const frame = frameId ? frameGetter?.(frameId) : void 0;
+        const view = frame?.view;
+        if (view) {
+          const eventName = handlerName + SPLITTER + eventType;
+          const fn = Reflect.get(view, eventName);
+          if (fn) {
+            const extendedEvent = domEvent;
+            extendedEvent.eventTarget = target;
+            extendedEvent.params = params ? parseUri(params).params : {};
+            funcWithTry(fn, [extendedEvent], view, noop);
+          }
+        }
+      }
+    }
+    const rangeFrameId = current.getAttribute("data-range-fid");
+    const rangeGuid = current.getAttribute("data-range-guid");
+    if (rangeFrameId && rangeGuid) {
+      const rangeMap = rangeEvents[rangeFrameId];
+      if (rangeMap?.[rangeGuid]?.[eventType]) {
+        break;
+      }
+    }
+    if (domEvent.isPropagationStopped?.()) {
+      break;
+    }
+    current = current.parentElement;
+  }
+}
+var EventDelegator = {
+  /**
+   * Bind a DOM event type to document body.
+   */
+  bind(eventType, hasSelector = false) {
+    const counter = rootEvents[eventType] || 0;
+    if (counter === 0) {
+      document.body.addEventListener(eventType, domEventProcessor, true);
+    }
+    rootEvents[eventType] = counter + 1;
+    if (hasSelector) {
+      selectorEvents[eventType] = (selectorEvents[eventType] || 0) + 1;
+    }
+  },
+  /**
+   * Unbind a DOM event type from document body.
+   */
+  unbind(eventType, hasSelector = false) {
+    const counter = rootEvents[eventType] || 0;
+    if (counter <= 1) {
+      document.body.removeEventListener(eventType, domEventProcessor, true);
+      Reflect.deleteProperty(rootEvents, eventType);
+    } else {
+      rootEvents[eventType] = counter - 1;
+    }
+    if (hasSelector) {
+      const selectorCounter = selectorEvents[eventType] || 0;
+      if (selectorCounter <= 1) {
+        Reflect.deleteProperty(selectorEvents, eventType);
+      } else {
+        selectorEvents[eventType] = selectorCounter - 1;
+      }
+    }
+  },
+  /**
+   * Clean up range events for a destroyed view.
+   */
+  clearRangeEvents(viewId) {
+    Reflect.deleteProperty(rangeEvents, viewId);
+    Reflect.deleteProperty(rangeFrames, viewId);
+  },
+  /**
+   * Set the frame getter function (called by Framework.boot).
+   */
+  setFrameGetter(getter) {
+    frameGetter = getter;
+  },
+  /**
+   * Get next element GUID.
+   */
+  nextElementGuid() {
+    return ++elementGuid;
+  }
+};
+
+// src/vdom.ts
+var WrapMeta = {
+  option: [1, "<select multiple>"],
+  thead: [1, "<table>"],
+  col: [2, "<table><colgroup>"],
+  tr: [2, "<table><tbody>"],
+  td: [3, "<table><tbody><tr>"],
+  area: [1, "<map>"],
+  param: [1, "<object>"],
+  g: [1, '<svg xmlns="' + SVG_NS + '">'],
+  m: [1, '<math xmlns="' + MATH_NS + '">'],
+  _: [0, ""]
+};
+WrapMeta["optgroup"] = WrapMeta["option"];
+WrapMeta["tbody"] = WrapMeta["tfoot"] = WrapMeta["colgroup"] = WrapMeta["caption"] = WrapMeta["thead"];
+WrapMeta["th"] = WrapMeta["td"];
+var VDoc = document.implementation.createHTMLDocument("");
+var VBase = VDoc.createElement("base");
+VBase.href = document.location.href;
+VDoc.head.appendChild(VBase);
+var VDomSpecials = {
+  INPUT: ["value", "checked"],
+  TEXTAREA: ["value"],
+  OPTION: ["selected"]
+};
+function vdomUnmountFrames(frame, node) {
+  if (node.nodeType === 1) {
+    const el = node;
+    const id = el.getAttribute("id");
+    if (id) {
+      frame.unmountZone(id);
+      const children = frame.children();
+      if (children.includes(id)) {
+        frame.unmountFrame(id);
+      }
+    }
+  }
+}
+function vdomGetNode(html, refNode) {
+  const tmp = VDoc.createElement("div");
+  const ns = refNode.namespaceURI;
+  let tag;
+  if (ns === SVG_NS) {
+    tag = "g";
+  } else if (ns === MATH_NS) {
+    tag = "m";
+  } else {
+    const match = TAG_NAME_REGEX.exec(html);
+    tag = match ? match[1] : "";
+  }
+  const wrap = WrapMeta[tag] || WrapMeta["_"];
+  tmp.innerHTML = wrap[1] + html;
+  let j = wrap[0];
+  while (j--) {
+    const last = tmp.lastChild;
+    if (last) tmp.replaceChildren(last);
+  }
+  return tmp;
+}
+function vdomGetCompareKey(node) {
+  if (node.nodeType !== 1) return void 0;
+  const el = node;
+  if (el.compareKeyCached) {
+    return el.cachedCompareKey;
+  }
+  let key = el.autoId ? "" : el.getAttribute("id") || void 0;
+  if (!key) {
+    key = el.getAttribute(TAG_KEY) || void 0;
+  }
+  if (!key) {
+    const larkView = el.getAttribute(LARK_VIEW);
+    if (larkView) {
+      key = parseUri(larkView).path || void 0;
+    }
+  }
+  el.compareKeyCached = 1;
+  el.cachedCompareKey = key || "";
+  return key;
+}
+function vdomSpecialDiff(oldNode, newNode) {
+  const nodeName = oldNode.nodeName;
+  const specials = VDomSpecials[nodeName];
+  if (!specials) return 0;
+  const oldEl = oldNode;
+  const newEl = newNode;
+  let result = 0;
+  for (const prop of specials) {
+    if (oldEl[prop] !== newEl[prop]) {
+      result = 1;
+      oldEl[prop] = newEl[prop];
+    }
+  }
+  return result;
+}
+function vdomSetAttributes(oldNode, newNode, ref, keepId) {
+  const oldEl = oldNode;
+  Reflect.deleteProperty(oldEl, "compareKeyCached");
+  const oldAttrs = oldNode.attributes;
+  const newAttrs = newNode.attributes;
+  for (let i = oldAttrs.length; i--; ) {
+    const name = oldAttrs[i].name;
+    if (!newNode.hasAttribute(name)) {
+      if (name === "id") {
+        if (!keepId) {
+          ref.idUpdates.push([oldNode, ""]);
+        }
+      } else {
+        ref.hasChanged = 1;
+        oldNode.removeAttribute(name);
+      }
+    }
+  }
+  for (let i = newAttrs.length; i--; ) {
+    const attr = newAttrs[i];
+    const key = attr.name;
+    const value = attr.value;
+    if (oldNode.getAttribute(key) !== value) {
+      if (key === "id") {
+        ref.idUpdates.push([oldNode, value]);
+      } else {
+        ref.hasChanged = 1;
+        oldNode.setAttribute(key, value);
+      }
+    }
+  }
+}
+function vdomSetChildNodes(oldParent, newParent, ref, frame, keys_) {
+  let oldNode = oldParent.lastChild;
+  let newNode = newParent.firstChild;
+  let extra = 0;
+  const keyedNodes = {};
+  const newKeyedNodes = {};
+  while (oldNode) {
+    extra++;
+    const nodeKey = vdomGetCompareKey(oldNode);
+    if (nodeKey) {
+      const bucket = keyedNodes[nodeKey] || (keyedNodes[nodeKey] = []);
+      bucket.push(oldNode);
+    }
+    oldNode = oldNode.previousSibling;
+  }
+  while (newNode) {
+    const nodeKey = vdomGetCompareKey(newNode);
+    if (nodeKey) {
+      newKeyedNodes[nodeKey] = (newKeyedNodes[nodeKey] || 0) + 1;
+    }
+    newNode = newNode.nextSibling;
+  }
+  newNode = newParent.firstChild;
+  oldNode = oldParent.firstChild;
+  while (newNode) {
+    extra--;
+    const tempNew = newNode;
+    newNode = newNode.nextSibling;
+    const nodeKey = vdomGetCompareKey(tempNew);
+    let foundNode = nodeKey ? keyedNodes[nodeKey] : void 0;
+    if (foundNode && (foundNode = foundNode.slice()) && foundNode.length) {
+      const matched = foundNode.pop();
+      while (matched !== oldNode) {
+        const next = oldNode?.nextSibling ?? null;
+        oldParent.appendChild(oldNode);
+        oldNode = next;
+      }
+      oldNode = matched.nextSibling;
+      if (nodeKey && newKeyedNodes[nodeKey]) {
+        newKeyedNodes[nodeKey]--;
+      }
+      vdomSetNode(matched, tempNew, oldParent, ref, frame, keys_);
+    } else if (oldNode) {
+      const tempOld2 = oldNode;
+      const oldKey = vdomGetCompareKey(tempOld2);
+      if (oldKey && keyedNodes[oldKey] && newKeyedNodes[oldKey]) {
+        extra++;
+        ref.hasChanged = 1;
+        ref.domOps.push([8, oldParent, tempNew, tempOld2]);
+      } else {
+        oldNode = oldNode.nextSibling;
+        vdomSetNode(tempOld2, tempNew, oldParent, ref, frame, keys_);
+      }
+    } else {
+      ref.hasChanged = 1;
+      ref.domOps.push([1, oldParent, tempNew]);
+    }
+  }
+  let tempOld = oldParent.lastChild;
+  while (extra-- > 0) {
+    if (tempOld) {
+      vdomUnmountFrames(frame, tempOld);
+      ref.domOps.push([2, oldParent, tempOld]);
+      tempOld = tempOld.previousSibling;
+      ref.hasChanged = 1;
+    }
+  }
+}
+function vdomSetNode(oldNode, newNode, oldParent, ref, frame, keys_) {
+  if (vdomSpecialDiff(oldNode, newNode) || oldNode.nodeType === 1 && oldNode.hasAttribute(TAG_VIEW_KEY) || !(oldNode.isEqualNode && oldNode.isEqualNode(newNode))) {
+    if (oldNode.nodeType === newNode.nodeType && oldNode.nodeName === newNode.nodeName) {
+      if (oldNode.nodeType === 1) {
+        const oldEl = oldNode;
+        const newEl = newNode;
+        const staticKey = newEl.getAttribute(TAG_KEY);
+        if (staticKey && staticKey === oldEl.getAttribute(TAG_KEY)) {
+          return;
+        }
+        const newLarkView = newEl.getAttribute(LARK_VIEW);
+        const updateAttribute = !newEl.getAttribute(TAG_ATTR_KEY) || newEl.getAttribute(TAG_ATTR_KEY) !== oldEl.getAttribute(TAG_ATTR_KEY);
+        let updateChildren = true;
+        if (newLarkView) {
+          const oldFrameId = oldEl.getAttribute("id") || "";
+          const newViewPath = parseUri(newLarkView).path;
+          const oldLarkView = oldEl.getAttribute(LARK_VIEW);
+          const oldViewPath = oldLarkView ? parseUri(oldLarkView).path : "";
+          if (oldFrameId && newViewPath === oldViewPath) {
+            updateChildren = false;
+          }
+        }
+        if (updateAttribute) {
+          vdomSetAttributes(oldEl, newEl, ref, !!newLarkView);
+        }
+        if (updateChildren) {
+          vdomSetChildNodes(oldEl, newEl, ref, frame, keys_);
+        }
+      } else if (oldNode.nodeValue !== newNode.nodeValue) {
+        ref.hasChanged = 1;
+        oldNode.nodeValue = newNode.nodeValue;
+      }
+    } else {
+      ref.hasChanged = 1;
+      vdomUnmountFrames(frame, oldNode);
+      ref.domOps.push([4, oldParent, newNode, oldNode]);
+    }
+  }
+}
+function createVdomRef() {
+  return {
+    idUpdates: [],
+    views: [],
+    domOps: [],
+    hasChanged: 0
+  };
+}
+function applyVdomOps(ops) {
+  for (const op of ops) {
+    switch (op[0]) {
+      case 1:
+        op[1].appendChild(op[2]);
+        break;
+      case 2:
+        op[1].removeChild(op[2]);
+        break;
+      case 4:
+        op[1].replaceChild(op[2], op[3]);
+        break;
+      case 8:
+        op[1].insertBefore(op[2], op[3]);
+        break;
+    }
+  }
+}
+function applyIdUpdates(updates) {
+  for (const [element, newId] of updates) {
+    if (newId) {
+      element.setAttribute("id", newId);
+    } else {
+      element.removeAttribute("id");
+    }
+  }
+}
+var EncoderMap = {
+  "&": "amp",
+  "<": "lt",
+  ">": "gt",
+  '"': "#34",
+  "'": "#39",
+  "`": "#96"
+};
+var ENCODE_REGEX = /[&<>"'`]/g;
+function encodeHTML(v) {
+  return String(v == null ? "" : v).replace(
+    ENCODE_REGEX,
+    (m) => "&" + EncoderMap[m] + ";"
+  );
+}
+function encodeSafe(v) {
+  return String(v == null ? "" : v);
+}
+var URIMap = {
+  "!": "%21",
+  "'": "%27",
+  "(": "%28",
+  ")": "%29",
+  "*": "%2A"
+};
+var URI_ENCODE_REGEX = /[!')(*]/g;
+function encodeURIExtra(v) {
+  return encodeURIComponent(encodeSafe(v)).replace(
+    URI_ENCODE_REGEX,
+    (m) => URIMap[m]
+  );
+}
+var QUOTE_REGEX = /['"\\]/g;
+function encodeQ(v) {
+  return encodeSafe(v).replace(QUOTE_REGEX, "\\$&");
+}
+
+// src/updater.ts
+function updaterRef(refData, value, key) {
+  const counter = refData[SPLITTER];
+  for (let i = counter; --i; ) {
+    key = SPLITTER + i;
+    if (refData[key] === value) {
+      return key;
+    }
+  }
+  key = SPLITTER + refData[SPLITTER]++;
+  refData[key] = value;
+  return key;
+}
+var Updater = class {
+  /** View ID (same as owner frame ID) */
+  viewId;
+  /** Current data object */
+  data;
+  /** Ref data for template rendering */
+  refData;
+  /** Changed keys in current digest cycle */
+  changedKeys = {};
+  /** Whether data has changed since last digest */
+  hasChangedFlag = 0;
+  /** Digesting queue: supports re-digest during digest */
+  digestingQueue = [];
+  /** Snapshot JSON string for altered() detection */
+  snapshotJson;
+  constructor(viewId) {
+    this.viewId = viewId;
+    this.data = { vId: viewId };
+    const refCounter = {};
+    refCounter[SPLITTER] = 1;
+    this.refData = refCounter;
+    this.hasChangedFlag = 1;
+  }
+  /**
+   * Get data by key.
+   * Returns entire data object if key is omitted.
+   */
+  get(key) {
+    let result = this.data;
+    if (key) {
+      result = this.data[key];
+    }
+    if (typeof window !== "undefined" && window.__lark_debug) {
+      return safeguard(result);
+    }
+    return result;
+  }
+  /**
+   * Set data, tracking changed keys.
+   * Returns this for chaining.
+   */
+  set(data, excludes) {
+    this.hasChangedFlag = setData(data, this.data, this.changedKeys, excludes || /* @__PURE__ */ new Set()) || this.hasChangedFlag ? 1 : 0;
+    return this;
+  }
+  /**
+   * Detect changes and trigger VDOM re-render.
+   *
+   * The core rendering pipeline:
+   * 1. Set data if provided
+   * 2. If changed, run VDOM diff (template → new DOM → diff against old DOM)
+   * 3. Apply DOM operations
+   * 4. Apply ID updates
+   * 5. Call endUpdate on views that need re-rendering
+   * 6. Support re-digest during digest via queue
+   */
+  digest(data, excludes, callback) {
+    if (data) {
+      this.set(data, excludes);
+    }
+    const digesting = this.digestingQueue;
+    if (callback) {
+      digesting.push(callback);
+    }
+    if (digesting.length > 0 && digesting[0] === null) {
+      return;
+    }
+    this.runDigest(digesting);
+  }
+  /**
+   * Core digest execution.
+   */
+  runDigest(digesting) {
+    const startIndex = digesting.length;
+    digesting.push(null);
+    const keys2 = this.changedKeys;
+    const changed = this.hasChangedFlag;
+    this.hasChangedFlag = 0;
+    this.changedKeys = {};
+    const frame = Frame.get(this.viewId);
+    const view = frame?.view;
+    const node = getById(this.viewId);
+    if (changed && view && node && view.signature > 0) {
+      const tmpl = view.tmpl;
+      if (tmpl && typeof tmpl === "function") {
+        const html = tmpl(
+          this.data,
+          this.viewId,
+          this.refData,
+          encodeHTML,
+          encodeSafe,
+          encodeURIExtra,
+          updaterRef,
+          encodeQ
+        );
+        const newDom = vdomGetNode(html, node);
+        const ref = createVdomRef();
+        vdomSetChildNodes(node, newDom, ref, frame, keys2);
+        applyIdUpdates(ref.idUpdates);
+        applyVdomOps(ref.domOps);
+        for (const v of ref.views) {
+          if (v.render) {
+            funcWithTry(v.render, [], v, noop);
+          }
+        }
+        if (ref.hasChanged || !view.rendered) {
+          view.endUpdate(this.viewId);
+        }
+      }
+    }
+    if (digesting.length > startIndex + 1) {
+      this.runDigest(digesting);
+    } else {
+      const callbacks = digesting.slice();
+      digesting.length = 0;
+      for (const cb of callbacks) {
+        if (cb) cb();
+      }
+    }
+  }
+  /**
+   * Save a snapshot of current data for altered() detection.
+   */
+  snapshot() {
+    this.snapshotJson = JSON.stringify(this.data);
+    return this;
+  }
+  /**
+   * Check if data has changed since last snapshot.
+   */
+  altered() {
+    if (this.snapshotJson) {
+      return this.snapshotJson !== JSON.stringify(this.data);
+    }
+    return void 0;
+  }
+  /**
+   * Translate data references (SPLITTER-prefixed values).
+   */
+  translate(data) {
+    if (typeof data === "string" && data[0] === SPLITTER) {
+      return has(this.refData, data) ? this.refData[data] : data;
+    }
+    return data;
+  }
+  /**
+   * Parse expression with data context.
+   */
+  parse(expr) {
+    try {
+      const fn = new Function("data", `with(data) { return ${expr}; }`);
+      return fn(this.refData);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get changed keys (for external inspection).
+   */
+  getChangedKeys() {
+    return this.changedKeys;
+  }
+};
+
+// src/view.ts
+var VIEW_GLOBALS = {};
+if (typeof window !== "undefined") {
+  VIEW_GLOBALS["win"] = window;
+}
+if (typeof document !== "undefined") {
+  VIEW_GLOBALS["doc"] = document;
+}
+function viewPrepare(oView) {
+  if (oView.ctors) {
+    return oView.ctors;
+  }
+  const ctors = [];
+  oView.ctors = ctors;
+  const proto = oView.prototype;
+  const eventsObject = {};
+  const eventsList = [];
+  const selectorObject = {};
+  const mixins = proto["mixins"];
+  if (mixins && Array.isArray(mixins)) {
+    viewMergeMixins(mixins, oView, ctors);
+  }
+  for (const p in proto) {
+    if (!has(proto, p)) continue;
+    const currentFn = proto[p];
+    if (typeof currentFn !== "function") continue;
+    const matches = p.match(VIEW_EVT_METHOD_REG);
+    if (!matches) continue;
+    const isSelector = matches[1];
+    const selectorOrCallback = matches[2];
+    const events = matches[3];
+    const modifiers = matches[4];
+    const mod = {};
+    if (modifiers) {
+      for (const item of modifiers.split(",")) {
+        mod[item] = true;
+      }
+    }
+    const eventTypes = events.split(",");
+    for (const item of eventTypes) {
+      const globalNode = VIEW_GLOBALS[selectorOrCallback];
+      let mask = 1;
+      if (isSelector) {
+        if (globalNode) {
+          eventsList.push({
+            handler: currentFn,
+            element: globalNode,
+            eventName: item,
+            modifiers: mod
+          });
+          continue;
+        }
+        mask = 2;
+        let selectorEntry = selectorObject[item];
+        if (!selectorEntry) {
+          selectorEntry = selectorObject[item] = {
+            selectors: []
+          };
+        }
+        if (!selectorEntry[selectorOrCallback]) {
+          selectorEntry[selectorOrCallback] = 1;
+          selectorEntry.selectors.push(selectorOrCallback);
+        }
+      }
+      eventsObject[item] = (eventsObject[item] || 0) | mask;
+      const combinedKey = selectorOrCallback + SPLITTER + item;
+      const existingFn = proto[combinedKey];
+      if (!existingFn) {
+        proto[combinedKey] = currentFn;
+      } else {
+        const mixinFn = currentFn;
+        const existingMixin = existingFn;
+        if (existingMixin.b) {
+          if (mixinFn.b) {
+            proto[combinedKey] = processMixinsSameEvent(
+              currentFn,
+              existingFn
+            );
+          } else if (has(proto, p)) {
+            proto[combinedKey] = currentFn;
+          }
+        }
+      }
+    }
+  }
+  viewWrapMethod(proto, "render", "$b");
+  proto["$eo"] = eventsObject;
+  proto["$el"] = eventsList;
+  proto["$so"] = selectorObject;
+  proto["$f"] = proto["assign"];
+  return ctors;
+}
+function viewWrapMethod(proto, fnName, shortKey) {
+  const originalFn = proto[fnName];
+  if (typeof originalFn !== "function") return;
+  const wrapped = function(...args) {
+    if (this.signature > 0) {
+      this.signature++;
+      this.fire("rendercall");
+      destroyAllResources(this, false);
+      const instanceFn = typeof this[fnName] === "function" ? this[fnName] : originalFn;
+      const fnToCall = instanceFn === wrapped ? originalFn : instanceFn;
+      return funcWithTry(fnToCall, args, this, noop);
+    }
+    return void 0;
+  };
+  proto[fnName] = wrapped;
+  proto[shortKey] = wrapped;
+}
+function processMixinsSameEvent(additional, exist) {
+  let temp;
+  const existMixin = exist;
+  if (existMixin.a) {
+    temp = existMixin;
+  } else {
+    temp = function(...e) {
+      funcWithTry(temp.a ?? [], e, this, noop);
+    };
+    temp.a = [exist];
+    temp.b = 1;
+  }
+  const additionalMixin = additional;
+  temp.a = (temp.a ?? []).concat(additionalMixin.a ?? [additional]);
+  return temp;
+}
+function viewMergeMixins(mixins, viewClass, ctors) {
+  const proto = viewClass.prototype;
+  const temp = {};
+  for (const node of mixins) {
+    for (const p in node) {
+      if (!has(node, p)) continue;
+      const fn = node[p];
+      const exist = temp[p];
+      if (p === "ctor") {
+        ctors.push(fn);
+        continue;
+      }
+      if (VIEW_EVT_METHOD_REG.test(p)) {
+        if (exist) {
+          temp[p] = processMixinsSameEvent(fn, exist);
+        } else {
+          fn.b = 1;
+          temp[p] = fn;
+        }
+      } else {
+        if (!exist) {
+          temp[p] = fn;
+        }
+      }
+    }
+  }
+  for (const p in temp) {
+    if (!has(proto, p)) {
+      proto[p] = temp[p];
+    }
+  }
+}
+function viewDelegateEvents(view, destroy = false) {
+  const proto = Object.getPrototypeOf(view) ?? {};
+  const eventsObject = proto["$eo"] || view.eventObjectMap;
+  const selectorObject = proto["$so"] || view.eventSelectorMap;
+  const eventsList = proto["$el"] || view.globalEventList;
+  for (const e in eventsObject) {
+    if (has(eventsObject, e)) {
+      if (destroy) {
+        EventDelegator.unbind(e, !!selectorObject[e]);
+      } else {
+        EventDelegator.bind(e, !!selectorObject[e]);
+      }
+    }
+  }
+  for (const entry of eventsList) {
+    if (destroy) {
+      entry.element.removeEventListener(
+        entry.eventName,
+        entry.boundHandler
+      );
+    } else {
+      const handler = entry.handler;
+      const element = entry.element;
+      const modifiers = entry.modifiers;
+      entry.boundHandler = function(domEvent) {
+        const extendedEvent = domEvent;
+        extendedEvent.eventTarget = element;
+        if (modifiers) {
+          const kbEvent = domEvent;
+          if (modifiers["ctrl"] && !kbEvent.ctrlKey || modifiers["shift"] && !kbEvent.shiftKey || modifiers["alt"] && !kbEvent.altKey || modifiers["meta"] && !kbEvent.metaKey) {
+            return;
+          }
+        }
+        funcWithTry(handler, [domEvent], view, noop);
+      };
+      entry.element.addEventListener(
+        entry.eventName,
+        entry.boundHandler
+      );
+    }
+  }
+}
+function destroyAllResources(view, lastly) {
+  const cache = view.resources;
+  for (const p in cache) {
+    if (has(cache, p)) {
+      const entry = cache[p];
+      if (lastly || entry.destroyOnRender) {
+        destroyResource(cache, p, true);
+      }
+    }
+  }
+}
+function destroyResource(cache, key, callDestroy, oldEntity) {
+  const entry = cache[key];
+  if (!entry || entry.entity === oldEntity) return void 0;
+  const entity = entry.entity;
+  if (entity && typeof entity === "object") {
+    const destroyFn = entity["destroy"];
+    if (typeof destroyFn === "function" && callDestroy) {
+      funcWithTry(destroyFn, [], entity, noop);
+    }
+  }
+  Reflect.deleteProperty(cache, key);
+  return entity;
+}
+var View = class _View {
+  /** View ID (same as owner frame ID) */
+  id = "";
+  /** Owner frame */
+  owner = 0;
+  /** Updater instance */
+  updater;
+  /** Signature: > 0 means active, incremented on render, 0 = destroyed */
+  signature = 0;
+  /** Whether rendered at least once */
+  rendered;
+  /** Whether view has template */
+  tmpl;
+  /** Location observation config */
+  locationObserved = {
+    flag: 0,
+    keys: [],
+    observePath: false
+  };
+  /** Observed state keys */
+  observedStateKeys;
+  /** Resource map */
+  resources = {};
+  /** Selector event map: eventType -> handler name list */
+  eventSelectorMap = {};
+  /** Event object map: eventType -> bitmask */
+  eventObjectMap = {};
+  /** Global event list */
+  globalEventList = [];
+  /** Assign method reference */
+  assignMethod;
+  /** Whether endUpdate pending */
+  endUpdatePending;
+  /** Internal event storage */
+  _events = new EventEmitter();
+  /**
+   * Initialize view (called by Frame when mounting).
+   */
+  init() {
+  }
+  /**
+   * Render view template (called by Frame after init).
+   * Wrapped by View_WrapMethod to manage signature + resources.
+   *
+   * Default implementation calls updater.digest() which:
+   * 1. Executes the template function with current data
+   * 2. Runs VDOM diff against previous DOM
+   * 3. Applies DOM operations
+   * 4. Calls endUpdate to mount child frames
+   *
+   */
+  render() {
+    this.updater.digest();
+  }
+  // ============================================================
+  // Event methods (delegate to internal EventEmitter)
+  // ============================================================
+  on(event, handler) {
+    this._events.on(event, handler);
+    return this;
+  }
+  off(event, handler) {
+    this._events.off(event, handler);
+    return this;
+  }
+  fire(event, data, remove, lastToFirst) {
+    this._events.fire(event, data, remove, lastToFirst);
+    return this;
+  }
+  // ============================================================
+  // Update methods
+  // ============================================================
+  /**
+   * Notify view that HTML update is about to begin.
+   * Unmounts child frames in the update zone.
+   */
+  beginUpdate(id) {
+    if (this.signature > 0 && this.endUpdatePending !== void 0) {
+      this.owner.unmountZone(id, true);
+    }
+  }
+  /**
+   * Notify view that HTML update has ended.
+   * Mounts child frames in the update zone and runs deferred invokes.
+   */
+  endUpdate(id, inner) {
+    if (this.signature > 0) {
+      const updateId = id || this.id;
+      let flag;
+      if (inner) {
+        flag = inner;
+      } else {
+        flag = this.endUpdatePending;
+        this.endUpdatePending = 1;
+        this.rendered = true;
+      }
+      const ownerFrame = this.owner;
+      ownerFrame.mountZone(updateId, inner);
+      if (!flag) {
+        setTimeout(
+          this.wrapAsync(() => {
+            runInvokes(ownerFrame);
+          }),
+          0
+        );
+      }
+    }
+  }
+  // ============================================================
+  // Async wrapper
+  // ============================================================
+  /**
+   * Wrap an async callback to check view signature before executing.
+   * If the view has been re-rendered or destroyed, the callback is skipped.
+   */
+  wrapAsync(fn, context) {
+    const currentSignature = this.signature;
+    return (...args) => {
+      if (currentSignature > 0 && currentSignature === this.signature) {
+        return fn.apply(context || this, args);
+      }
+      return void 0;
+    };
+  }
+  // ============================================================
+  // Location observation
+  // ============================================================
+  /**
+   * Observe location parameters or path changes.
+   * When observed keys change, render() is called automatically.
+   */
+  observeLocation(params, observePath = false) {
+    const loc = this.locationObserved;
+    loc.flag = 1;
+    if (typeof params === "object" && !Array.isArray(params)) {
+      if (params["path"]) {
+        observePath = true;
+      }
+      const paramKeys = params["params"];
+      if (paramKeys) {
+        params = paramKeys;
+      }
+    }
+    loc.observePath = observePath;
+    if (params) {
+      if (typeof params === "string") {
+        loc.keys = params.split(",");
+      } else if (Array.isArray(params)) {
+        loc.keys = params;
+      }
+    }
+  }
+  // ============================================================
+  // State observation
+  // ============================================================
+  /**
+   * Observe State data keys for changes.
+   * When observed keys change via State.digest(), render() is called.
+   */
+  observeState(observedKeys) {
+    if (typeof observedKeys === "string") {
+      this.observedStateKeys = observedKeys.split(",");
+    } else {
+      this.observedStateKeys = observedKeys;
+    }
+  }
+  // ============================================================
+  // Resource management
+  // ============================================================
+  /**
+   * Capture (register) a resource under a key.
+   * If a resource already exists at that key, it's destroyed first.
+   * When destroyOnRender=true, the resource is destroyed on next render call.
+   */
+  capture(key, resource, destroyOnRender = false) {
+    const cache = this.resources;
+    if (resource) {
+      destroyResource(cache, key, true, resource);
+      cache[key] = {
+        entity: resource,
+        destroyOnRender
+      };
+    } else {
+      const entry = cache[key];
+      return entry ? entry.entity : void 0;
+    }
+    return resource;
+  }
+  /**
+   * Release a captured resource.
+   * If destroy=true, calls the resource's destroy() method.
+   */
+  release(key, destroy = true) {
+    return destroyResource(this.resources, key, destroy);
+  }
+  // ============================================================
+  // Leave tip
+  // ============================================================
+  /**
+   * Set up a leave confirmation for route changes and page unload.
+   */
+  leaveTip(message, condition) {
+    const changeListener = function(e) {
+      const isRouterChange = e.type === ROUTER_EVENTS.CHANGE;
+      const aKey = isRouterChange ? "a" : "b";
+      const bKey = isRouterChange ? "b" : "a";
+      if (changeListener[aKey]) {
+        if (typeof e.prevent === "function") {
+          e.prevent();
+        }
+        if (typeof e.reject === "function") {
+          e.reject();
+        }
+      } else if (condition()) {
+        if (typeof e.prevent === "function") {
+          e.prevent();
+        }
+        changeListener[bKey] = 1;
+        if (typeof e.resolve === "function") {
+          e.resolve();
+        }
+      }
+    };
+    const unloadListener = (e) => {
+      if (condition()) {
+        e["msg"] = message;
+      }
+    };
+    const changeFn = changeListener;
+    const unloadFn = unloadListener;
+    Router.on(ROUTER_EVENTS.CHANGE, changeFn);
+    Router.on(ROUTER_EVENTS.PAGE_UNLOAD, unloadFn);
+    this.on("unload", changeFn);
+    this.on("destroy", () => {
+      Router.off(ROUTER_EVENTS.CHANGE, changeFn);
+      Router.off(ROUTER_EVENTS.PAGE_UNLOAD, unloadFn);
+    });
+  }
+  // ============================================================
+  // Static: extend and merge
+  // ============================================================
+  /** Collected ctors from mixins */
+  static ctors;
+  /**
+   * Extend View to create a new View subclass.
+   *
+   * Supports:
+   * - props.ctor: constructor-like init (called with initParams + {node, deep})
+   * - props.mixins: array of mixin objects
+   * - Event method patterns: `'name<click>'` etc.
+   */
+  static extend(props, statics) {
+    props = props || {};
+    const ctor = props["ctor"];
+    const ctors = [];
+    if (ctor) {
+      ctors.push(ctor);
+    }
+    const ParentView = this;
+    const ChildView = class extends ParentView {
+      constructor(nodeId, ownerFrame, initParams, node, mixinCtors) {
+        super(nodeId, ownerFrame, initParams, node, []);
+        for (const key in props) {
+          if (has(props, key) && key !== "ctor") {
+            this[key] = props[key];
+          }
+        }
+        this.id = nodeId;
+        this.owner = ownerFrame;
+        this.updater = new Updater(nodeId);
+        const params = [
+          initParams,
+          {
+            node,
+            deep: !this.tmpl
+          }
+        ];
+        const concatCtors = ctors.concat(mixinCtors || []);
+        if (concatCtors.length) {
+          funcWithTry(concatCtors, params, this, noop);
+        }
+      }
+    };
+    const proto = ChildView.prototype;
+    for (const key in props) {
+      if (has(props, key) && key !== "ctor") {
+        proto[key] = props[key];
+      }
+    }
+    if (statics) {
+      for (const key in statics) {
+        if (has(statics, key)) {
+          ChildView[key] = statics[key];
+        }
+      }
+    }
+    ChildView.merge = viewMerge;
+    ChildView.extend = _View.extend;
+    return ChildView;
+  }
+  /**
+   * Merge mixins into View prototype.
+   */
+  static merge(...mixins) {
+    const self = this;
+    const existingCtors = self.ctors || [];
+    viewMergeMixins(mixins, self, existingCtors);
+    return self;
+  }
+};
+function viewMerge(...mixins) {
+  const self = this;
+  const existingCtors = self.ctors || [];
+  viewMergeMixins(mixins, self, existingCtors);
+  return self;
+}
+function runInvokes(frame) {
+  const list = frame.invokeList;
+  if (!list) return;
+  while (list.length) {
+    const entry = list.shift();
+    if (entry && !entry.removed) {
+      frame.invoke(entry.name, entry.args);
+    }
+  }
+}
+
+// src/frame.ts
+var frameRegistry = /* @__PURE__ */ new Map();
+var rootFrame;
+var globalAlter;
+var frameCache = [];
+var staticEmitter = new EventEmitter();
+var viewClassRegistry = {};
+var Frame = class _Frame extends EventEmitter {
+  /** Frame ID (same as owner DOM element ID) */
+  id;
+  /** Parent Frame ID */
+  _parentId = void 0;
+  get parentId() {
+    return this._parentId;
+  }
+  /** Children map: id -> id */
+  childrenMap = {};
+  /** Children count */
+  childrenCount = 0;
+  /** Ready count (children that have fired 'created') */
+  readyCount = 0;
+  /** Ready map: id -> 1 */
+  readyMap = {};
+  /** View instance */
+  viewInstance;
+  /** Get view instance (read-only) */
+  get view() {
+    return this.viewInstance;
+  }
+  /** Invoke list for deferred method calls */
+  invokeList = [];
+  /** Signature for async operation tracking */
+  signature = 1;
+  /** Whether view has altered */
+  hasAltered = 0;
+  /** Whether view is destroyed */
+  destroyed = 0;
+  /** View path (lark-view attribute value) */
+  viewPath;
+  /** Original template before mount */
+  originalTemplate;
+  /** Hold fire created flag */
+  holdFireCreated = 0;
+  /** Children created flag */
+  childrenCreated = 0;
+  /** Children alter flag */
+  childrenAlter = 0;
+  constructor(id, parentId) {
+    super();
+    this.id = id;
+    if (parentId) {
+      this._parentId = parentId;
+    }
+    frameRegistry.set(id, this);
+    const element = document.getElementById(id);
+    if (element) {
+      element.frame = this;
+      element.frameBound = 1;
+    }
+    _Frame.fire("add", { frame: this });
+  }
+  // ============================================================
+  // Instance methods
+  // ============================================================
+  /**
+   * Mount a view to this frame.
+   *
+   * Complete flow:
+   * 1. Parse viewPath, translate query params from parent
+   * 2. Unmount current view
+   * 3. Load View class (via require or provided ViewClass)
+   * 4. View_Prepare (scan event methods)
+   * 5. Create View instance
+   * 6. View_DelegateEvents (bind DOM events)
+   * 7. Call view.init()
+   * 8. If view has tmpl, call render via Updater
+   * 9. If no tmpl, call endUpdate directly
+   */
+  mountView(viewPath, viewInitParams) {
+    const node = document.getElementById(this.id);
+    const pId = this.parentId;
+    if (!this.hasAltered && node) {
+      this.hasAltered = 1;
+      this.originalTemplate = node.innerHTML;
+    }
+    this.unmountView();
+    this.destroyed = 0;
+    const parsed = parseUri(viewPath || "");
+    const viewClassName = parsed.path;
+    if (!node || !viewClassName) return;
+    this.viewPath = viewPath;
+    const params = parsed["params"];
+    translateQuery(pId || this.id, viewPath, params);
+    if (viewInitParams) {
+      assign(params, viewInitParams);
+    }
+    const sign = this.signature;
+    if (viewClassRegistry[viewClassName]) {
+      this.doMountView(viewClassRegistry[viewClassName], params, node, sign);
+    }
+  }
+  /**
+   * Internal: actually mount the view after class is loaded.
+   */
+  doMountView(ViewClass, params, node, sign) {
+    if (sign !== this.signature) return;
+    const mixinCtors = viewPrepare(ViewClass);
+    const ViewConstructor = ViewClass;
+    const view = new ViewConstructor(
+      this.id,
+      this,
+      params,
+      node,
+      mixinCtors
+    );
+    this.viewInstance = view;
+    view.signature = 1;
+    viewDelegateEvents(view);
+    const initResult = funcWithTry(
+      view.init,
+      [params, { node, deep: !view.tmpl }],
+      view,
+      noop
+    );
+    const nextSign = ++this.signature;
+    Promise.resolve(initResult).then(() => {
+      if (nextSign !== this.signature) return;
+      if (view.tmpl) {
+        const renderFn = view.$b;
+        if (renderFn) {
+          renderFn.call(view);
+        }
+      } else {
+        this.hasAltered = 0;
+        if (!view.$e) {
+          view.endUpdate();
+        }
+      }
+    });
+  }
+  /**
+   * Unmount current view.
+   */
+  unmountView() {
+    const view = this.view;
+    this.invokeList = [];
+    if (!view) return;
+    if (!globalAlter) {
+      globalAlter = { id: this.id };
+    }
+    this.destroyed = 1;
+    this.unmountZone();
+    notifyAlter(this, globalAlter);
+    if (view.signature > 0) {
+      view.fire("destroy", void 0, true, true);
+    }
+    EventDelegator.clearRangeEvents(this.id);
+    delete this["viewInstance"];
+    const node = document.getElementById(this.id);
+    if (node && this.originalTemplate) {
+      node.innerHTML = this.originalTemplate;
+    }
+    globalAlter = void 0;
+    unmark(view);
+  }
+  /**
+   * Mount a child frame.
+   */
+  mountFrame(frameId, viewPath, viewInitParams) {
+    notifyAlter(this, { id: frameId });
+    let childFrame = frameRegistry.get(frameId);
+    if (!childFrame) {
+      if (!this.childrenMap[frameId]) {
+        this.childrenCount++;
+      }
+      this.childrenMap[frameId] = frameId;
+      childFrame = frameCache.pop();
+      if (childFrame) {
+        reInitFrame(childFrame, frameId, this.id);
+      } else {
+        childFrame = new _Frame(frameId, this.id);
+      }
+    }
+    childFrame.mountView(viewPath, viewInitParams);
+    return childFrame;
+  }
+  /**
+   * Unmount a child frame.
+   */
+  unmountFrame(id, _inner) {
+    const targetId = id ? this.childrenMap[id] : this.id;
+    const frame = frameRegistry.get(targetId);
+    if (!frame) return;
+    const wasCreated = frame.readyCount > 0;
+    const pId = frame.parentId;
+    frame.unmountView();
+    removeFrame(targetId, wasCreated);
+    reInitFrameForCache(frame);
+    frameCache.push(frame);
+    const parent = frameRegistry.get(pId || "");
+    if (parent && parent.childrenMap[targetId]) {
+      Reflect.deleteProperty(parent.childrenMap, targetId);
+      parent.childrenCount--;
+      notifyCreated(parent);
+    }
+  }
+  /**
+   * Mount all views in a zone.
+   */
+  mountZone(zoneId, _inner) {
+    const targetZone = zoneId || this.id;
+    this.holdFireCreated = 1;
+    const rootEl = document.getElementById(targetZone);
+    if (!rootEl) return;
+    const viewElements = rootEl.querySelectorAll(`[${LARK_VIEW}]`);
+    const frames = [];
+    viewElements.forEach((el) => {
+      const htmlEl = el;
+      if (!htmlEl.frameBound) {
+        const elId = ensureElementId2(htmlEl);
+        htmlEl.frameBound = 1;
+        const viewPath = getAttribute(htmlEl, LARK_VIEW);
+        frames.push([elId, viewPath]);
+      }
+    });
+    for (const [frameId, viewPath] of frames) {
+      this.mountFrame(frameId, viewPath);
+    }
+    this.holdFireCreated = 0;
+    notifyCreated(this);
+  }
+  /**
+   * Unmount all views in a zone.
+   */
+  unmountZone(zoneId, _inner) {
+    for (const childId in this.childrenMap) {
+      if (has(this.childrenMap, childId)) {
+        if (!zoneId || childId !== zoneId) {
+          this.unmountFrame(childId);
+        }
+      }
+    }
+    notifyCreated(this);
+  }
+  /**
+   * Get all child frame IDs.
+   */
+  children() {
+    const result = [];
+    for (const id in this.childrenMap) {
+      if (has(this.childrenMap, id)) {
+        result.push(id);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get parent frame at given level.
+   * @param level - How many levels up (default 1)
+   */
+  parent(level = 1) {
+    let frame = void 0;
+    let currentPid = this.parentId;
+    let n = level >>> 0 || 1;
+    while (currentPid && n--) {
+      frame = frameRegistry.get(currentPid);
+      currentPid = frame?.parentId;
+    }
+    return frame;
+  }
+  /**
+   * Invoke a method on the view.
+   */
+  invoke(name, args) {
+    let result;
+    const view = this.view;
+    if (view && view.rendered) {
+      const fn = view[name];
+      if (typeof fn === "function") {
+        result = funcWithTry(
+          fn,
+          args || [],
+          view,
+          noop
+        );
+      }
+    } else {
+      const key = SPLITTER + name;
+      let existingEntry;
+      for (const entry of this.invokeList) {
+        if (entry.key === key) {
+          existingEntry = entry;
+          break;
+        }
+      }
+      if (existingEntry) {
+        existingEntry.removed = args === existingEntry.args;
+      }
+      const newEntry = {
+        name,
+        args: args || [],
+        key
+      };
+      this.invokeList.push(newEntry);
+    }
+    return result;
+  }
+  // ============================================================
+  // Static methods
+  // ============================================================
+  /** Get frame by ID */
+  static get(id) {
+    return frameRegistry.get(id);
+  }
+  /** Get all frames */
+  static getAll() {
+    return frameRegistry;
+  }
+  /** Get or create root frame */
+  static root(rootId) {
+    if (!rootFrame) {
+      rootId = rootId || "lark-root";
+      let rootElement = document.getElementById(rootId);
+      if (!rootElement) {
+        rootElement = document.body;
+        rootElement.id = rootId;
+      }
+      rootFrame = new _Frame(rootId);
+    }
+    return rootFrame;
+  }
+  /** Bind event listener (static) */
+  static on(event, handler) {
+    staticEmitter.on(event, handler);
+    return _Frame;
+  }
+  /** Unbind event listener (static) */
+  static off(event, handler) {
+    staticEmitter.off(event, handler);
+    return _Frame;
+  }
+  /** Fire event (static) */
+  static fire(event, data) {
+    staticEmitter.fire(event, data);
+  }
+};
+function ensureElementId2(element) {
+  const id = element.getAttribute("id");
+  if (id) return id;
+  element.autoId = 1;
+  const newId = generateId("frame_");
+  element.id = newId;
+  return newId;
+}
+function removeFrame(id, wasCreated) {
+  const frameInstance = frameRegistry.get(id);
+  if (!frameInstance) return;
+  frameRegistry.delete(id);
+  Frame.fire("remove", { frame: frameInstance, fcc: wasCreated });
+  const element = document.getElementById(id);
+  if (element) {
+    element.frameBound = 0;
+    Reflect.deleteProperty(element, "frame");
+  }
+}
+function notifyCreated(frameInstance) {
+  if (!frameInstance["childrenCreated"] && !frameInstance["holdFireCreated"] && frameInstance["childrenCount"] === frameInstance["readyCount"]) {
+    if (!frameInstance["childrenCreated"]) {
+      frameInstance["childrenCreated"] = 1;
+      frameInstance["childrenAlter"] = 0;
+      frameInstance.fire("created");
+    }
+    const pId = frameInstance.parentId;
+    if (pId) {
+      const parent = frameRegistry.get(pId);
+      if (parent && !parent.readyMap[frameInstance.id]) {
+        parent.readyMap[frameInstance.id] = 1;
+        parent.readyCount++;
+        notifyCreated(parent);
+      }
+    }
+  }
+}
+function notifyAlter(frameInstance, data) {
+  if (!frameInstance["childrenAlter"] && frameInstance["childrenCreated"]) {
+    frameInstance["childrenCreated"] = 0;
+    frameInstance["childrenAlter"] = 1;
+    frameInstance.fire("alter", data);
+    const pId = frameInstance.parentId;
+    if (pId) {
+      const parent = frameRegistry.get(pId);
+      if (parent && parent.readyMap[frameInstance.id]) {
+        parent.readyCount--;
+        Reflect.deleteProperty(parent.readyMap, frameInstance.id);
+        notifyAlter(parent, data);
+      }
+    }
+  }
+}
+function reInitFrame(frame, id, parentId) {
+  Reflect.set(frame, "id", id);
+  frame["_parentId"] = parentId;
+  frame["childrenMap"] = {};
+  frame["childrenCount"] = 0;
+  frame["readyCount"] = 0;
+  frame["signature"] = 1;
+  frame["readyMap"] = {};
+  frame["invokeList"] = [];
+  frameRegistry.set(id, frame);
+}
+function reInitFrameForCache(frame) {
+  Reflect.set(frame, "id", "");
+  frame["_parentId"] = void 0;
+  frame["childrenMap"] = {};
+  frame["readyMap"] = {};
+}
+function translateQuery(pId, src, params) {
+  const parentFrame = frameRegistry.get(pId);
+  const parentView = parentFrame?.view;
+  if (!parentView) return;
+  const parentRefData = parentView.updater.refData;
+  if (!parentRefData) return;
+  if (src.indexOf(SPLITTER) > 0) {
+    translateData(parentRefData, params);
+    if (params[SPLITTER]) {
+      assign(
+        params,
+        params[SPLITTER]
+      );
+      Reflect.deleteProperty(params, SPLITTER);
+    }
+  }
+}
+function registerViewClass(viewPath, ViewClass) {
+  const parsed = parseUri(viewPath);
+  const path = parsed.path;
+  if (path) {
+    viewClassRegistry[path] = ViewClass;
+  }
+}
+
+// src/service.ts
+var Bag = class {
+  /** Bag data */
+  data;
+  /** Internal cache info */
+  cacheInfo;
+  constructor(data = {}) {
+    this.data = data;
+  }
+  /** Get a value from bag data */
+  get(key) {
+    return this.data[key];
+  }
+  /** Set a value in bag data */
+  set(keyOrData, value) {
+    if (typeof keyOrData === "string") {
+      this.data[keyOrData] = value;
+    } else {
+      assign(this.data, keyOrData);
+    }
+    return this;
+  }
+};
+var FETCH_FLAGS_ALL = 1;
+var FETCH_FLAGS_ONE = 2;
+function createServiceType(syncFn, cacheMax = 20, cacheBuffer = 5) {
+  const metas = {};
+  const bagCache = new Cache({
+    maxSize: cacheMax,
+    bufferSize: cacheBuffer
+  });
+  const pendingCacheKeys = {};
+  const staticEmitter2 = new EventEmitter();
+  const serviceType = {
+    add(attrs) {
+      if (!isArray(attrs)) {
+        attrs = [attrs];
+      }
+      for (const bag of attrs) {
+        if (bag) {
+          const name = bag.name;
+          const cache = bag.cache;
+          bag.cache = cache ? cache | 0 : 0;
+          metas[name] = bag;
+        }
+      }
+    },
+    meta(attrs) {
+      const name = typeof attrs === "string" ? attrs : attrs["name"];
+      return metas[name] || attrs;
+    },
+    create(attrs) {
+      const meta = serviceType.meta(attrs);
+      const cache = attrs["cache"] | 0 || meta.cache || 0;
+      const entity = new Bag();
+      entity.set(meta);
+      entity.cacheInfo = {
+        name: meta.name,
+        after: meta.after,
+        cleans: meta.cleans,
+        key: cache ? defaultCacheKey(meta, attrs) : "",
+        time: 0
+      };
+      if (typeof attrs === "object" && attrs !== null) {
+        entity.set(attrs);
+      }
+      const before = meta.before;
+      if (before) {
+        funcWithTry(before, [entity], entity, noop);
+      }
+      staticEmitter2.fire("begin", { bag: entity });
+      return entity;
+    },
+    get(attrs, createNew) {
+      let entity;
+      let needsUpdate = false;
+      if (!createNew) {
+        entity = serviceType.cached(attrs);
+      }
+      if (!entity) {
+        entity = serviceType.create(attrs);
+        needsUpdate = true;
+      }
+      return { entity, needsUpdate };
+    },
+    cached(attrs) {
+      const meta = serviceType.meta(attrs);
+      const cache = attrs["cache"] | 0 || meta.cache || 0;
+      let cacheKey = "";
+      if (cache) {
+        cacheKey = defaultCacheKey(meta, attrs);
+      }
+      if (cacheKey) {
+        const info = pendingCacheKeys[cacheKey];
+        if (info) {
+          return info.e;
+        }
+        const cached = bagCache.get(cacheKey);
+        if (cached && cached.cacheInfo) {
+          if (now() - cached.cacheInfo.time > cache) {
+            bagCache.del(cacheKey);
+            return void 0;
+          }
+          return cached;
+        }
+      }
+      return void 0;
+    },
+    clear(names) {
+      const nameList = (typeof names === "string" ? names : names.join(",")).split(",");
+      const nameSet = {};
+      for (const n of nameList) {
+        nameSet[n] = 1;
+      }
+      const keysToDelete = [];
+      bagCache.forEach((bag) => {
+        if (bag?.cacheInfo && nameSet[bag.cacheInfo.name]) {
+          if (bag.cacheInfo.key) {
+            keysToDelete.push(bag.cacheInfo.key);
+          }
+        }
+      });
+      for (const key of keysToDelete) {
+        bagCache.del(key);
+      }
+    },
+    on(event, handler) {
+      staticEmitter2.on(event, handler);
+    },
+    off(event, handler) {
+      staticEmitter2.off(event, handler);
+    },
+    fire(event, data) {
+      staticEmitter2.fire(event, data);
+    },
+    extend(newSyncFn, newCacheMax, newCacheBuffer) {
+      return createServiceType(
+        newSyncFn,
+        newCacheMax || cacheMax,
+        newCacheBuffer || cacheBuffer
+      );
+    }
+  };
+  const internals = {
+    metas,
+    bagCache,
+    pendingCacheKeys,
+    syncFn,
+    staticEmitter: staticEmitter2
+  };
+  function ServiceInstance() {
+    this.id = generateId("s");
+    this["$e"] = 0;
+    this["$d"] = 0;
+    this["$g"] = [];
+    this["$h"] = [];
+    this._emitter = new EventEmitter();
+    this._internals = internals;
+    this._type = serviceType;
+  }
+  ServiceInstance.prototype = {
+    all(attrs, done) {
+      serviceSend(this, attrs, done, FETCH_FLAGS_ALL, false);
+      return this;
+    },
+    one(attrs, done) {
+      serviceSend(this, attrs, done, FETCH_FLAGS_ONE, false);
+      return this;
+    },
+    save(attrs, done) {
+      serviceSend(this, attrs, done, FETCH_FLAGS_ALL, true);
+      return this;
+    },
+    enqueue(callback) {
+      if (!this["$d"]) {
+        this["$g"].push(callback);
+        this.dequeue(...this["$h"]);
+      }
+      return this;
+    },
+    dequeue(...args) {
+      if (!this["$e"] && !this["$d"]) {
+        this["$e"] = 1;
+        setTimeout(() => {
+          this["$e"] = 0;
+          if (!this["$d"]) {
+            const task2 = this["$g"].shift();
+            if (task2) {
+              this["$h"] = args;
+              funcWithTry(task2, args, this, noop);
+            }
+          }
+        }, 0);
+      }
+    },
+    destroy() {
+      this["$d"] = 1;
+      this["$g"] = [];
+    },
+    on(event, handler) {
+      this._emitter.on(event, handler);
+      return this;
+    },
+    off(event, handler) {
+      this._emitter.off(event, handler);
+      return this;
+    },
+    fire(event, data) {
+      this._emitter.fire(event, data);
+      return this;
+    }
+  };
+  const staticsMap = {
+    add: serviceType.add,
+    meta: serviceType.meta,
+    create: serviceType.create,
+    get: serviceType.get,
+    cached: serviceType.cached,
+    clear: serviceType.clear,
+    on: serviceType.on,
+    off: serviceType.off,
+    fire: serviceType.fire,
+    extend: serviceType.extend,
+    _internals: internals
+  };
+  const constructor = Object.assign(
+    ServiceInstance,
+    staticsMap
+  );
+  return constructor;
+}
+var Service = createServiceType(noop);
+function defaultCacheKey(meta, attrs) {
+  return JSON.stringify(attrs) + SPLITTER + JSON.stringify(meta);
+}
+function serviceSend(service, attrs, done, flag, save) {
+  if (service["$d"]) return;
+  if (service["$e"]) {
+    service.enqueue(
+      serviceSend.bind(null, service, attrs, done, flag, save)
+    );
+    return;
+  }
+  service["$e"] = 1;
+  let attrList;
+  if (typeof attrs === "string") {
+    attrList = [{ name: attrs }];
+  } else if (isArray(attrs)) {
+    attrList = attrs;
+  } else {
+    attrList = [attrs];
+  }
+  const internals = service._internals;
+  const { syncFn, pendingCacheKeys, staticEmitter: staticEmitter2 } = internals;
+  let requestCount = 0;
+  const total = attrList.length;
+  const doneArr = new Array(total + 1);
+  const errorArgs = [];
+  const remoteComplete = (idx, error) => {
+    const bag = doneArr[idx + 1];
+    let newBag = false;
+    if (error) {
+      errorArgs[idx] = error;
+      staticEmitter2.fire("fail", { bag, error });
+    } else {
+      newBag = true;
+      staticEmitter2.fire("done", { bag });
+    }
+    if (!service["$d"]) {
+      const finish = requestCount === total;
+      if (finish) {
+        service["$e"] = 0;
+        if (flag === FETCH_FLAGS_ALL) {
+          doneArr[0] = errorArgs;
+          funcWithTry(done, doneArr, service, noop);
+        }
+      }
+      if (flag === FETCH_FLAGS_ONE) {
+        funcWithTry(done, [error || null, bag, finish, idx], service, noop);
+      }
+    }
+    if (newBag) {
+      staticEmitter2.fire("end", { bag, error });
+    }
+  };
+  for (const attr of attrList) {
+    if (!attr) continue;
+    const attrObj = typeof attr === "string" ? { name: attr } : attr;
+    const bagInfo = service._type.get(attrObj, save);
+    const bagEntity = bagInfo.entity;
+    const cacheKey = bagEntity.cacheInfo?.key || "";
+    const complete = remoteComplete.bind(null, requestCount++);
+    if (cacheKey && pendingCacheKeys[cacheKey]) {
+      pendingCacheKeys[cacheKey].push(complete);
+    } else if (bagInfo.needsUpdate) {
+      if (cacheKey) {
+        const cacheList = [complete];
+        cacheList.e = bagEntity;
+        pendingCacheKeys[cacheKey] = cacheList;
+        const cacheComplete = () => {
+          const list = pendingCacheKeys[cacheKey];
+          const entity = list.e;
+          if (entity.cacheInfo) {
+            entity.cacheInfo.time = now();
+          }
+          internals.bagCache.set(cacheKey, entity);
+          Reflect.deleteProperty(pendingCacheKeys, cacheKey);
+          for (const cb of list) {
+            if (typeof cb === "function") {
+              cb();
+            }
+          }
+        };
+        syncFn(bagEntity, cacheComplete);
+      } else {
+        syncFn(bagEntity, complete);
+      }
+    } else {
+      complete();
+    }
+  }
+}
+
+// src/framework.ts
+var config = {
+  rootId: "lark-root",
+  hashbang: "#!",
+  error: (error) => {
+    throw error;
+  }
+};
+var booted3 = false;
+var taskList = [];
+var taskIndex = 0;
+var taskScheduled = false;
+function executeTaskChunk(deadline) {
+  const hasDeadline = !!deadline;
+  const startTime = now();
+  while (true) {
+    const fn = taskList[taskIndex];
+    if (!fn) {
+      taskList.length = 0;
+      taskIndex = 0;
+      taskScheduled = false;
+      return;
+    }
+    if (hasDeadline && deadline) {
+      if (deadline.timeRemaining() <= 0) {
+        scheduleTaskChunk();
+        return;
+      }
+    } else if (now() - startTime > CALL_BREAK_TIME && taskList.length > taskIndex + 3) {
+      scheduleTaskChunk();
+      return;
+    }
+    const context = taskList[taskIndex + 1];
+    const args = taskList[taskIndex + 2];
+    funcWithTry(fn, args, context, noop);
+    taskIndex += 3;
+  }
+}
+function scheduleTaskChunk() {
+  const scheduler = window.scheduler;
+  if (scheduler && typeof scheduler.postTask === "function") {
+    scheduler.postTask(() => executeTaskChunk(), { priority: "background" });
+  } else if (typeof window.requestIdleCallback === "function") {
+    window.requestIdleCallback(executeTaskChunk);
+  } else {
+    setTimeout(executeTaskChunk, 0);
+  }
+}
+function task(fn, args, context) {
+  taskList.push(fn, context, args || []);
+  if (!taskScheduled) {
+    taskScheduled = true;
+    scheduleTaskChunk();
+  }
+}
+var dispatcherUpdateTag = 0;
+function viewIsObserveChanged(view) {
+  const loc = view.locationObserved;
+  let result = false;
+  if (loc.flag) {
+    if (loc.observePath) {
+      const lastChanged2 = Router.diff();
+      result = !!lastChanged2?.path;
+    }
+    if (!result && loc.keys.length) {
+      const lastChanged2 = Router.diff();
+      const changedParams = lastChanged2?.params;
+      if (changedParams) {
+        for (const key of loc.keys) {
+          result = has(changedParams, key);
+          if (result) break;
+        }
+      }
+    }
+  }
+  return result;
+}
+function stateIsObserveChanged(view, stateKeys) {
+  const observedKeys = view.observedStateKeys;
+  if (!observedKeys) return false;
+  for (const key of observedKeys) {
+    if (has(stateKeys, key)) return true;
+  }
+  return false;
+}
+function dispatcherUpdate(frame, stateKeys) {
+  const frameInternal = frame;
+  const view = frame.view;
+  if (!view || frameInternal.dispatcherUpdateTag === dispatcherUpdateTag || view.signature <= 1) {
+    return;
+  }
+  frameInternal.dispatcherUpdateTag = dispatcherUpdateTag;
+  const isChanged = stateKeys ? stateIsObserveChanged(view, stateKeys) : viewIsObserveChanged(view);
+  let renderPromise;
+  if (isChanged) {
+    const renderResult = funcWithTry(view.$b ?? view.render, [], view, noop);
+    if (renderResult && typeof renderResult.then === "function") {
+      renderPromise = renderResult;
+    }
+  }
+  const children = frame.children();
+  const recurse = () => {
+    for (const childId of children) {
+      const childFrame = Frame.get(childId);
+      if (childFrame) {
+        dispatcherUpdate(childFrame, stateKeys);
+      }
+    }
+  };
+  if (renderPromise) {
+    renderPromise.then(recurse);
+  } else {
+    recurse();
+  }
+}
+function dispatcherNotifyChange(e) {
+  const rootFrame2 = Frame.root();
+  const view = e["view"];
+  if (view) {
+    const viewPath = typeof view === "object" && view !== null ? String(view.to || "") : String(view);
+    rootFrame2.mountView(viewPath);
+  } else {
+    dispatcherUpdateTag++;
+    dispatcherUpdate(rootFrame2, e["keys"]);
+  }
+}
+function dispatchEvent(target, eventType, eventInit) {
+  const event = new CustomEvent(eventType, {
+    bubbles: true,
+    cancelable: true,
+    ...eventInit
+  });
+  target.dispatchEvent(event);
+}
+var Base = class extends EventEmitter {
+};
+function use(names, callback) {
+  if (!config.require) {
+    if (callback) callback();
+    return;
+  }
+  const nameList = typeof names === "string" ? [names] : names;
+  const result = config.require(nameList);
+  if (result && typeof result.then === "function") {
+    result.then((modules) => {
+      if (callback) callback(modules);
+    });
+  }
+}
+var WAIT_OK = 1;
+var WAIT_TIMEOUT_OR_UNFOUND = 0;
+function waitZoneViewsRendered(viewId, timeout) {
+  if (timeout == null) {
+    timeout = 30 * 1e3;
+  }
+  const checkFrame = Frame.get(viewId);
+  const endTime = now() + timeout;
+  return new Promise((resolve) => {
+    const check = () => {
+      const currentTime = now();
+      if (currentTime > endTime || !checkFrame) {
+        resolve(WAIT_TIMEOUT_OR_UNFOUND);
+      } else if (checkFrame.childrenCount === checkFrame.readyCount) {
+        resolve(WAIT_OK);
+      } else {
+        setTimeout(check, 9);
+      }
+    };
+    setTimeout(check, 9);
+  });
+}
+var Framework = {
+  // ============================================================
+  // Lifecycle
+  // ============================================================
+  /**
+   * Get or set framework configuration.
+   */
+  config(cfg) {
+    if (!cfg) {
+      return config;
+    }
+    if (typeof cfg === "string") {
+      return config[cfg];
+    }
+    assign(config, cfg);
+    return config;
+  },
+  /**
+   * Boot the framework.
+   */
+  boot(cfg) {
+    if (cfg && typeof cfg === "object") {
+      assign(config, cfg);
+    }
+    Router._setConfig(config);
+    EventDelegator.setFrameGetter((id) => Frame.get(id));
+    Router.on(ROUTER_EVENTS.CHANGED, (data) => {
+      dispatcherNotifyChange(data);
+    });
+    State.on(ROUTER_EVENTS.CHANGED, (data) => {
+      dispatcherNotifyChange(data);
+    });
+    booted3 = true;
+    markBooted();
+    markRouterBooted();
+    const rootFrame2 = Frame.root(config.rootId);
+    Router._bind();
+    const defaultView = config.defaultView || "";
+    if (defaultView) {
+      rootFrame2.mountView(defaultView);
+    }
+  },
+  /** Whether framework has booted */
+  isBooted() {
+    return booted3;
+  },
+  // ============================================================
+  // Utility proxies
+  // ============================================================
+  /** Mark async callback validity tracker */
+  mark,
+  /** Unmark (invalidate) async callbacks */
+  unmark,
+  /** Fire a custom DOM event on a target */
+  dispatch: dispatchEvent,
+  /** Execute function in try-catch, ignoring errors */
+  task,
+  /** Promise-based setTimeout */
+  delay(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+  },
+  /** Load modules via configured require */
+  use,
+  /** Wait for zone views to be rendered */
+  waitZoneViewsRendered,
+  WAIT_OK,
+  WAIT_TIMEOUT_OR_UNFOUND,
+  /**
+   * Convert array to hash map.
+   */
+  toMap,
+  /**
+   * Execute function in try-catch.
+   */
+  toTry: funcWithTry,
+  /**
+   * Convert path + params to URL string.
+   */
+  toUrl: toUri,
+  /**
+   * Parse URI string into path and params.
+   */
+  parseUrl: parseUri,
+  /**
+   * Mix properties from source to target.
+   */
+  mix: assign,
+  /**
+   * Check if object has own property.
+   */
+  has,
+  /**
+   * Get object keys.
+   */
+  keys,
+  /**
+   * Check if node A is inside node B.
+   */
+  inside: nodeInside,
+  /**
+   * Get element by ID (shorthand for document.getElementById).
+   */
+  node: getById,
+  /**
+   * Apply CSS style.
+   */
+  applyStyle,
+  /**
+   * Generate globally unique ID.
+   */
+  guid: generateId,
+  /**
+   * Proxy-based debug guard.
+   */
+  guard: safeguard,
+  /**
+   * Cache class.
+   */
+  Cache,
+  /**
+   * Ensure element has an ID.
+   */
+  nodeId(element) {
+    if (!element.id) {
+      element.id = generateId("l_");
+    }
+    return element.id;
+  },
+  /**
+   * Base class with EventEmitter.
+   */
+  Base,
+  // ============================================================
+  // Module access
+  // ============================================================
+  /** Router module */
+  Router,
+  /** State module */
+  State,
+  /** View class */
+  View,
+  /** Frame class */
+  Frame
+};
+if (typeof window !== "undefined") {
+  window.__lark_Framework = Framework;
+  window.__lark_State = State;
+  window.__lark_Router = Router;
+  window.__lark_Frame = Frame;
+}
+
+// src/store.ts
+var LARK_GLOBAL = "lark_global";
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["Lark"] = "lark";
+  Platform2["React"] = "react";
+  Platform2["Node"] = "node";
+  return Platform2;
+})(Platform || {});
+var isFunction = (val) => typeof val === "function";
+var isObject = (val) => val !== null && typeof val === "object";
+var isPromise = (val) => isObject(val) && isFunction(val["then"]);
+var hasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+var deepClone = (obj) => {
+  if (!obj || !isObject(obj)) return {};
+  const newData = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));
+  for (const key in obj) {
+    if (hasOwnProperty(obj, key)) {
+      const value = obj[key];
+      newData[key] = isObject(value) ? deepClone(value) : value;
+    }
+  }
+  return newData;
+};
+var cloneData = (data) => isObject(data) ? deepClone(data) : data;
+var getDataByKey = (target, key) => {
+  let data;
+  const rec = target;
+  if (key.includes(".")) {
+    key.split(".").forEach((k, index) => {
+      data = index === 0 ? rec?.[k] : data?.[k];
+    });
+  } else {
+    data = rec?.[key];
+  }
+  return data;
+};
+var Queue = class {
+  pendingTasks = /* @__PURE__ */ new Set();
+  queue = [];
+  flushTasks() {
+    const { pendingTasks, queue } = this;
+    const flushTickTask = () => {
+      while (queue.length > 0) {
+        const task2 = queue.shift();
+        pendingTasks.delete(task2);
+        runTask(task2);
+      }
+    };
+    Promise.resolve().then(flushTickTask);
+  }
+  add(tasks) {
+    const isQueueEmpty = this.queue.length === 0;
+    for (const { cb, params } of tasks) {
+      addParams2Callback(cb, params);
+      if (!this.pendingTasks.has(cb)) {
+        this.queue.push(cb);
+        this.pendingTasks.add(cb);
+      }
+    }
+    if (isQueueEmpty) this.flushTasks();
+  }
+  delete(tasks) {
+    if (this.pendingTasks.size === 0) return;
+    for (const { cb } of tasks) {
+      if (this.pendingTasks.has(cb)) {
+        this.pendingTasks.delete(cb);
+        const index = this.queue.findIndex((item) => item === cb);
+        if (index !== -1) this.queue.splice(index, 1);
+      }
+    }
+  }
+  clear() {
+    this.queue = [];
+    this.pendingTasks.clear();
+  }
+};
+var addParams2Callback = (cb, params) => {
+  if (!cb || !params) return;
+  const cbObj = cb;
+  if (isObject(cb) && isObject(cbObj["params"])) {
+    Object.assign(cbObj["params"], params);
+  } else {
+    cbObj["params"] = params;
+  }
+};
+var runTask = (cb) => {
+  const cbObj = cb;
+  const params = cbObj["params"];
+  delete cbObj["params"];
+  try {
+    cb(params);
+  } catch {
+  }
+};
+var getDefScheduler = () => new Queue();
+var run = (tasks, scheduler) => {
+  if (scheduler) {
+    if (isFunction(scheduler)) {
+      for (const { cb, params } of tasks) scheduler(cb, params);
+    } else {
+      scheduler.add(tasks);
+    }
+  } else {
+    for (const { cb, params } of tasks) cb(params);
+  }
+};
+var ArrMethods = {};
+["indexOf", "lastIndexOf", "includes"].forEach((key) => {
+  const rawMethod = Array.prototype[key];
+  ArrMethods[key] = function(...args) {
+    let res = rawMethod.apply(this, args);
+    if (res === -1 || res === false) {
+      res = rawMethod.apply(
+        this,
+        args.map((item) => ProxyCache.get(item) ?? item)
+      );
+    }
+    return res;
+  };
+});
+var inArrUpdate = false;
+["unshift", "shift", "push", "pop", "splice"].forEach((key) => {
+  const rawMethod = Array.prototype[key];
+  ArrMethods[key] = function(...args) {
+    inArrUpdate = true;
+    const result = rawMethod.apply(this, args);
+    inArrUpdate = false;
+    return result;
+  };
+});
+function needKeepArrItem(target, newVal, key) {
+  if (!Array.isArray(target) || !inArrUpdate) return false;
+  return getLinkKeys(newVal) === createLinkKeys(target, key);
+}
+var defStateConfig = {
+  belong: LARK_GLOBAL,
+  linkKeys: "",
+  shallow: false
+};
+var StateConfigMap = /* @__PURE__ */ new WeakMap();
+var setStateConfig = (target, config2) => {
+  if (target && isObject(config2)) StateConfigMap.set(target, config2);
+};
+var getStateConfig = (target, key) => {
+  if (!StateConfigMap.has(target)) return void 0;
+  const config2 = StateConfigMap.get(target);
+  return key ? config2[key] : config2;
+};
+var isState = (target) => isObject(target) && StateConfigMap.has(target);
+var createLinkKeys = (target, property) => {
+  if (!hasLinkKeys(target)) return property;
+  if (Array.isArray(target)) return getLinkKeys(target) ?? property;
+  return `${getLinkKeys(target)}.${property}`;
+};
+var formatLinkKeys = (target, key) => {
+  const originKeysStr = getLinkKeys(target);
+  if (!originKeysStr) return null;
+  const linkKeys = [];
+  const originKeys = originKeysStr.split(".");
+  let pre = "";
+  for (const k of originKeys) {
+    const curr = pre ? `${pre}.${k}` : k;
+    linkKeys.push(curr);
+    pre = curr;
+  }
+  linkKeys.push(`${originKeysStr}.${key}`);
+  return linkKeys;
+};
+var getLinkKeys = (target) => getStateConfig(target, "linkKeys");
+var hasLinkKeys = (target) => !!getLinkKeys(target);
+var ProxyCache = /* @__PURE__ */ new WeakMap();
+var keepKey = null;
+var keep = (key) => {
+  if (keepKey) throw new Error("[lark-store] keepKey is not null");
+  keepKey = key;
+};
+var needKeep = (key) => {
+  if (keepKey === key) {
+    keepKey = null;
+    return true;
+  }
+  return false;
+};
+var canSetNewVal = (params) => {
+  const { property, newVal, oldVal } = params;
+  if (hasOwnProperty(params.target, property) && newVal === oldVal)
+    return false;
+  return true;
+};
+var getNewVal = (params) => {
+  const { target, newVal, property, needKeepVal = false } = params;
+  const config2 = getStateConfig(target);
+  if (!isObject(newVal)) return newVal;
+  if (needKeepArrItem(target, newVal, property)) return newVal;
+  if (config2?.shallow) return newVal;
+  if (needKeepVal) return newVal;
+  const linkKeys = createLinkKeys(target, property);
+  const newState = createState(newVal, {
+    ...config2,
+    linkKeys
+  });
+  if (isPromise(newVal)) handlePromise(newVal, target, property);
+  return newState;
+};
+var genPayload = (params) => {
+  const { target, property, newVal, oldVal } = params;
+  const config2 = getStateConfig(target) || defStateConfig;
+  return {
+    belong: config2.belong || LARK_GLOBAL,
+    target,
+    keys: formatLinkKeys(target, property) || [property],
+    newVal,
+    oldVal
+  };
+};
+var handlePromise = (child, parent, key) => {
+  child.then((res) => {
+    const parentProxy = ProxyCache.get(parent);
+    if (parentProxy) {
+      const oldVal = parentProxy[key];
+      if (ProxyCache.get(child) === oldVal) {
+        parentProxy[key] = res;
+      }
+    }
+  }).catch((err) => {
+    const parentProxy = ProxyCache.get(parent);
+    if (parentProxy) {
+      const oldVal = parentProxy[key];
+      if (ProxyCache.get(child) === oldVal) {
+        parentProxy[key] = err;
+      }
+    }
+  });
+};
+var _deleteKey = "_delete";
+var _markObjKey = "_markObj";
+var mark2 = (host, key) => {
+  let sign;
+  if (!host[_deleteKey]) {
+    const markHost = host[_markObjKey] || (host[_markObjKey] = {});
+    if (!hasOwnProperty(markHost, key)) {
+      markHost[key] = 0;
+    }
+    sign = ++markHost[key];
+  }
+  return () => {
+    const temp = host[_markObjKey];
+    return !!temp && sign === temp[key];
+  };
+};
+var unmark2 = (host) => {
+  host[_deleteKey] = 1;
+  host[_markObjKey] = 0;
+};
+function createState(initialData, config2) {
+  if (!isObject(initialData)) return initialData;
+  const mergedConfig = Object.assign({ ...defStateConfig }, config2);
+  const data = Array.isArray(initialData) ? [] : Object.create(Object.getPrototypeOf(initialData));
+  const handler = {
+    get(target, property, _receiver) {
+      if (Array.isArray(target) && property in ArrMethods) {
+        return ArrMethods[property];
+      }
+      return Reflect.get(target, property);
+    },
+    set(target, property, newVal, receiver) {
+      const strProp = property;
+      const oldVal = Reflect.get(target, property);
+      const preventTrigger = isLazySet(strProp);
+      const needKeepVal = needKeep(strProp);
+      const canSet = canSetNewVal({
+        target,
+        property: strProp,
+        newVal,
+        oldVal
+      });
+      if (!canSet) return true;
+      const proxyTarget = receiver || state;
+      newVal = getNewVal({
+        target: proxyTarget,
+        property: strProp,
+        newVal,
+        needKeepVal
+      });
+      Reflect.set(target, property, newVal, receiver);
+      if (preventTrigger) return true;
+      const payload = genPayload({
+        target: proxyTarget,
+        property: strProp,
+        newVal,
+        oldVal
+      });
+      trigger(payload);
+      return true;
+    },
+    deleteProperty(target, property) {
+      const strProp = property;
+      if (!hasOwnProperty(target, strProp)) return true;
+      const oldVal = Reflect.get(target, property);
+      Reflect.deleteProperty(target, property);
+      const payload = genPayload({
+        target: state,
+        property: strProp,
+        newVal: null,
+        oldVal
+      });
+      trigger(payload);
+      return true;
+    }
+  };
+  const state = new Proxy(data, handler);
+  ProxyCache.set(initialData, state);
+  setStateConfig(state, mergedConfig);
+  lazySet(state, initialData);
+  return state;
+}
+var currLazySetKey = null;
+function lazySet(target, data) {
+  if (isObject(data)) {
+    Reflect.ownKeys(data).forEach((key) => {
+      const strKey = key;
+      if (currLazySetKey) throw new Error("[lark-store] lazy set key conflict");
+      currLazySetKey = strKey;
+      target[strKey] = data[strKey];
+    });
+  }
+}
+function isLazySet(property) {
+  if (currLazySetKey === property) {
+    currLazySetKey = "";
+    return true;
+  }
+  return false;
+}
+function shallowSet(target, key, data) {
+  if (!isState(target))
+    throw new Error("[lark-store] shallowSet only supports state objects");
+  if (!isObject(data)) return target[key] = data;
+  keep(key);
+  const config2 = getStateConfig(target);
+  const linkKeys = createLinkKeys(target, key);
+  target[key] = createState(data, {
+    ...config2,
+    linkKeys,
+    shallow: true
+  });
+}
+var GlobalDeps = /* @__PURE__ */ new Map();
+function track(payload) {
+  const { belong, trackList = [] } = payload;
+  let deps = GlobalDeps.get(belong);
+  if (!deps) GlobalDeps.set(belong, deps = /* @__PURE__ */ new Map());
+  for (const { key, cb } of trackList) {
+    if (isFunction(cb)) {
+      let callbacks = deps.get(key);
+      if (!callbacks) deps.set(key, callbacks = /* @__PURE__ */ new Set());
+      callbacks.add(cb);
+    }
+  }
+}
+function trigger(payload) {
+  const { belong, keys: keys2 } = payload;
+  const store = getStore(belong);
+  if (store && store.status !== 2 /* ACTIVE */ && belong !== LARK_GLOBAL)
+    return;
+  const deps = GlobalDeps.get(belong);
+  if (!deps) return;
+  const tasks = /* @__PURE__ */ new Set();
+  for (const key of keys2) {
+    const callbacks = deps.get(key);
+    if (callbacks) {
+      for (const cb of callbacks) {
+        tasks.add({ cb, params: { [key]: true } });
+      }
+    }
+  }
+  if (tasks.size === 0) return;
+  const scheduler = store?.scheduler;
+  run(Array.from(tasks), scheduler);
+}
+function clear(payload) {
+  if (!payload) {
+    GlobalDeps.clear();
+    return;
+  }
+  const { belong, clearList } = payload;
+  const deps = GlobalDeps.get(belong);
+  if (!deps) return;
+  const store = getStore(belong);
+  const scheduler = store?.scheduler;
+  if (clearList) {
+    for (const { key, cb } of clearList) {
+      const callbacks = deps.get(key);
+      if (callbacks) {
+        if (!cb) {
+          deps.delete(key);
+        } else if (callbacks.has(cb)) {
+          callbacks.delete(cb);
+          if (scheduler && !isFunction(scheduler)) {
+            scheduler.delete([{ cb }]);
+          }
+          if (callbacks.size === 0) deps.delete(key);
+        }
+      }
+    }
+  } else {
+    deps.clear();
+    GlobalDeps.delete(belong);
+    if (scheduler && !isFunction(scheduler)) {
+      scheduler.clear();
+    }
+  }
+}
+var _storeName = /* @__PURE__ */ Symbol("store-name");
+var _storeStatus = /* @__PURE__ */ Symbol("store-status");
+var _storeScheduler = /* @__PURE__ */ Symbol("store-scheduler");
+var _storeCreate = /* @__PURE__ */ Symbol("fn:store-create");
+var _storeBoot = /* @__PURE__ */ Symbol("fn:store-boot");
+var _storeDestroy = /* @__PURE__ */ Symbol("fn:store-destroy");
+var _innerStore = /* @__PURE__ */ Symbol("inner-store");
+var _outerStore = /* @__PURE__ */ Symbol("outer-store");
+var _originState = /* @__PURE__ */ Symbol("origin-state");
+var _stateKeys = /* @__PURE__ */ Symbol("state-keys");
+var _storeState = /* @__PURE__ */ Symbol("store-state");
+var _storeDefScheduler = /* @__PURE__ */ Symbol("store-def-scheduler");
+var _storeProxy = /* @__PURE__ */ Symbol("fn:store-proxy");
+var BaseStore = class {
+  [_storeStatus] = 0 /* BEFORE_CREATE */;
+  [_storeDefScheduler] = getDefScheduler;
+  [_storeBoot]() {
+    this[_storeStatus] = 2 /* ACTIVE */;
+    return this[_storeProxy](true);
+  }
+  [_storeDestroy]() {
+    clear({ belong: this[_storeName] });
+    this[_storeState] = createState(this[_originState], {
+      belong: this[_storeName]
+    });
+    this[_storeStatus] = 3 /* DESTROYED */;
+  }
+  /**
+   *
+   * @param body - The object returned by the creator function
+   * @param excludeFns - Function keys to exclude from handlers (e.g. ['observe'])
+   */
+  [_storeCreate](body, excludeFns = ["observe"]) {
+    this[_storeStatus] = 1 /* CREATED */;
+    if (isObject(body)) {
+      const state = {};
+      const handlers = {};
+      Reflect.ownKeys(body).forEach((key) => {
+        const strKey = key;
+        const val = body[strKey];
+        if (isFunction(val)) {
+          if (!excludeFns.includes(strKey)) handlers[strKey] = val;
+        } else {
+          state[strKey] = val;
+        }
+      });
+      Object.assign(this, handlers);
+      this[_originState] = cloneData(state);
+      this[_stateKeys] = Object.keys(state);
+      this[_storeState] = createState(state, { belong: this[_storeName] });
+    }
+  }
+  constructor(name, config2) {
+    this[_storeName] = name;
+    this[_storeScheduler] = config2?.scheduler || this[_storeDefScheduler]();
+    this[_outerStore] = this[_storeProxy](true);
+  }
+  [_innerStore]() {
+    return this[_storeProxy]();
+  }
+  get status() {
+    return this[_storeStatus];
+  }
+  get storeName() {
+    return this[_storeName];
+  }
+  get scheduler() {
+    return this[_storeScheduler];
+  }
+  [_storeProxy](toOut = false) {
+    const self = this;
+    return new Proxy(self, {
+      get(target, property) {
+        if (self[_stateKeys].includes(property)) {
+          const val = self[_storeState][property];
+          return toOut ? cloneData(val) : val;
+        }
+        return Reflect.get(target, property);
+      },
+      set(_target, property, val) {
+        if (toOut) return true;
+        if (self[_stateKeys].includes(property)) {
+          self[_storeState][property] = val;
+        }
+        return true;
+      },
+      has(target, property) {
+        return Reflect.has(target, property) || self[_stateKeys].includes(property);
+      }
+    });
+  }
+};
+var LarkUtils = {
+  isLarkView(instance) {
+    return isObject(instance) && !!instance.updater;
+  },
+  getRender(view) {
+    return view.updater.digest.bind(view.updater);
+  },
+  getDataSetter(view) {
+    return view.updater.set.bind(view.updater);
+  },
+  onDestroy(view, cb) {
+    view.on("destroy", cb);
+  }
+};
+var getLarkAdapter = (storeName) => ({
+  Store: LarkStore,
+  useStore: ((view) => {
+    const store = getStore(storeName);
+    return store[_storeBoot](view);
+  })
+});
+var innerObserveFlags = /* @__PURE__ */ Symbol("store-inner-observe-flags");
+var boundViews = /* @__PURE__ */ Symbol("bound-views");
+var LarkStore = class extends BaseStore {
+  [boundViews] = /* @__PURE__ */ new Set();
+  [innerObserveFlags] = /* @__PURE__ */ new Set();
+  [_storeBoot](view) {
+    if (view && LarkUtils.isLarkView(view) && !this[boundViews].has(view)) {
+      this[boundViews].add(view);
+      LarkUtils.onDestroy(view, () => {
+        this[boundViews].delete(view);
+      });
+    }
+    return super[_storeBoot]();
+  }
+  [_storeDestroy]() {
+    this[boundViews].clear();
+    this[innerObserveFlags].clear();
+    super[_storeDestroy]();
+  }
+  observe(view, keys2, defCallback) {
+    if (this[_storeStatus] !== 2 /* ACTIVE */) return noop;
+    let observeKeys = keys2;
+    const _view = view;
+    const renderFn = _view ? LarkUtils.getRender(_view) : noop;
+    const dateSetterFn = _view ? LarkUtils.getDataSetter(_view) : noop;
+    const isInnerObserve = !view;
+    const innerFlags = /* @__PURE__ */ new Set();
+    const storeInnerObserveFlags = this[innerObserveFlags];
+    if (isFunction(keys2)) {
+      const res = keys2();
+      if (Array.isArray(res)) observeKeys = res;
+    }
+    const defSetter = (immediate, key, alias, transform) => () => {
+      const stateVal = getDataByKey(this, key);
+      let data = { [alias || key]: stateVal };
+      if (transform && isFunction(transform)) {
+        const newData = transform(stateVal);
+        if (isObject(newData)) data = newData;
+      }
+      if (immediate) dateSetterFn(data);
+      else renderFn(data);
+    };
+    const getList = (immediate = false) => {
+      const list = [];
+      for (const item of observeKeys) {
+        if (!item) continue;
+        const payload = typeof item === "string" ? { key: item } : item;
+        const { cb: cbDefault = defCallback, key } = payload;
+        let cb = cbDefault;
+        const { alias, lazy = true, transform } = payload;
+        if (!key) continue;
+        const c1 = !immediate;
+        const c2 = !cb && !!_view;
+        const c3 = !!cb && String(lazy) === "false";
+        if (!(c1 || c2 || c3)) continue;
+        if (isInnerObserve && cb) {
+          const flag = `storeInner_${key}_${observeKeys.join("-")}_${cb.toString()}`;
+          if (!storeInnerObserveFlags.has(flag)) {
+            storeInnerObserveFlags.add(flag);
+            innerFlags.add(flag);
+          }
+        }
+        if (c2) cb = defSetter(immediate, key, alias, transform);
+        if (cb) list.push({ key, cb });
+      }
+      return list;
+    };
+    const trackList = getList();
+    track({ belong: this[_storeName], trackList });
+    if (_view) {
+      LarkUtils.onDestroy(
+        _view,
+        () => clear({ belong: this[_storeName], clearList: trackList })
+      );
+    }
+    if (!isInnerObserve) run(getList(true));
+    return () => {
+      clear({ belong: this[_storeName], clearList: trackList });
+      innerFlags.forEach((flag) => storeInnerObserveFlags.delete(flag));
+    };
+  }
+};
+var getReactAdapter = (storeName) => ({
+  Store: ReactStore,
+  useStore: (() => {
+    const store = getStore(storeName);
+    return store[_storeBoot]();
+  })
+});
+var observeSym = /* @__PURE__ */ Symbol("observe");
+var getLastState = /* @__PURE__ */ Symbol("get-last-state");
+var ReactStore = class extends BaseStore {
+  stateChangeCount = 0;
+  lastCount = 0;
+  lastState = null;
+  constructor(name, config2) {
+    const effectiveConfig = config2 && !config2.scheduler ? {
+      ...config2,
+      scheduler: (cb, params) => cb(params)
+    } : config2;
+    super(name, effectiveConfig);
+  }
+  [_storeCreate](body) {
+    super[_storeCreate](body);
+    this[observeSym](() => {
+      this.stateChangeCount += 1;
+    });
+  }
+  isStateChanged() {
+    const currCount = this.stateChangeCount;
+    const changed = this.lastCount !== currCount;
+    this.lastCount = currCount;
+    return changed;
+  }
+  [getLastState](handlers) {
+    if (this.isStateChanged() || !this.lastState) {
+      const state = this[_storeState];
+      const immutableState = freezeData(state);
+      this.lastState = Object.assign({}, handlers, immutableState);
+    }
+    return this.lastState;
+  }
+  [observeSym](cb) {
+    const tasks = this[_stateKeys].map((key) => ({ key, cb }));
+    track({ belong: this[_storeName], trackList: tasks });
+    return () => clear({ belong: this[_storeName], clearList: tasks });
+  }
+};
+var freezeData = (target) => {
+  const data = {};
+  const keys2 = Object.keys(target);
+  for (const key of keys2) {
+    const value = target[key];
+    if (Array.isArray(value)) {
+      data[key] = value.map(
+        (item) => isObject(item) ? freezeData(item) : item
+      );
+    } else if (isObject(value)) {
+      data[key] = freezeData(value);
+    } else {
+      data[key] = value;
+    }
+  }
+  return data;
+};
+var getNodeAdapter = (storeName) => ({
+  Store: NodeStore,
+  useStore: (() => {
+    const store = getStore(storeName);
+    return store[_storeBoot]();
+  })
+});
+var NodeStore = class extends BaseStore {
+  observe(key, callback, immediate = true) {
+    const tasks = [{ key, cb: callback }];
+    track({ belong: this[_storeName], trackList: tasks });
+    if (immediate) run(tasks);
+    return () => clear({ belong: this[_storeName], clearList: tasks });
+  }
+};
+var getAdapter = (platform, storeName) => {
+  switch (platform) {
+    case "react" /* React */:
+      return getReactAdapter(storeName);
+    case "node" /* Node */:
+      return getNodeAdapter(storeName);
+    case "lark" /* Lark */:
+    default:
+      return getLarkAdapter(storeName);
+  }
+};
+var getPlatform = (comp) => {
+  if (LarkUtils.isLarkView(comp)) return "lark" /* Lark */;
+  return void 0;
+};
+var extendApis = { lazySet, shallowSet };
+var StoreCache = /* @__PURE__ */ new Map();
+function defineStore(name, creator, config2) {
+  if (StoreCache.has(name)) {
+    name = name + "_copy";
+  }
+  const { platform = "lark" /* Lark */ } = config2 || {};
+  const adapter = getAdapter(platform, name);
+  const StoreClass = adapter.Store;
+  const useStore = adapter.useStore;
+  const store = new StoreClass(name, config2);
+  store[_storeCreate](
+    creator(
+      store[_innerStore](),
+      extendApis
+    )
+  );
+  Object.defineProperties(useStore, {
+    $storeName: { value: name, configurable: true },
+    $del: { value: () => store[_storeDestroy](), configurable: true }
+  });
+  if (!StoreCache.has(name)) {
+    StoreCache.set(name, { store, creator, config: config2, useStore });
+  }
+  return useStore;
+}
+function getStore(name) {
+  if (name && StoreCache.has(name)) {
+    const entry = StoreCache.get(name);
+    return entry ? entry.store : void 0;
+  }
+  return void 0;
+}
+function delStore(name) {
+  if (name && StoreCache.has(name)) StoreCache.delete(name);
+}
+function getUseStore(name) {
+  if (name && StoreCache.has(name)) {
+    const entry = StoreCache.get(name);
+    return entry ? entry.useStore : void 0;
+  }
+  return void 0;
+}
+function cloneStore(name, useStore, config2) {
+  const oldStoreName = useStore["$storeName"];
+  const cached = StoreCache.get(oldStoreName);
+  const oldStoreCreator = cached?.creator;
+  const oldConfig = cached?.config || {};
+  if (!name || !oldStoreCreator) return;
+  const mergedConfig = { ...oldConfig, ...config2 || {} };
+  return defineStore(
+    name,
+    oldStoreCreator,
+    mergedConfig
+  );
+}
+function isStoreActive(name) {
+  if (name && StoreCache.has(name)) {
+    const entry = StoreCache.get(name);
+    return entry ? entry.store.status === 2 /* ACTIVE */ : false;
+  }
+  return false;
+}
+var cellCount = 0;
+function cell(data) {
+  return createState(data, {
+    belong: LARK_GLOBAL,
+    linkKeys: `${LARK_GLOBAL}_${cellCount++}`
+  });
+}
+function observeCell(state, cb, immediate = true) {
+  const linkKeys = getLinkKeys(state);
+  if (!linkKeys)
+    return () => {
+    };
+  const keys2 = linkKeys.split(".");
+  const key = keys2[keys2.length - 1];
+  const list = [{ key, cb }];
+  track({ belong: LARK_GLOBAL, trackList: list });
+  if (immediate) cb();
+  return () => clear({ belong: LARK_GLOBAL, clearList: list });
+}
+function multi(useStore) {
+  const storeName = useStore["$storeName"];
+  const flagSym = `lark_comp_${storeName}`;
+  const map = /* @__PURE__ */ new Map();
+  let rootViewPath;
+  const getFlag = (viewContext) => {
+    const owner = viewContext["owner"];
+    const viewPath = owner?.["path"] || "";
+    const viewId = owner?.["id"] || "";
+    let flag;
+    if (viewPath === rootViewPath) {
+      flag = `${flagSym}_${viewId}`;
+    } else {
+      flag = owner?.["viewInitParams"]?.[flagSym];
+    }
+    if (owner && isFunction(owner["mountFrame"])) {
+      const rawMountFrame = owner["mountFrame"];
+      owner["mountFrame"] = (vfId, viewPath2, viewInitParams = {}) => rawMountFrame.call(
+        owner,
+        vfId,
+        viewPath2,
+        Object.assign(viewInitParams, { [flagSym]: flag })
+      );
+    }
+    return flag;
+  };
+  const useFn = ((view) => {
+    if (!view)
+      throw new Error("[lark-store] multi: cannot find the view instance");
+    const viewCtx = view;
+    const flag = viewCtx[flagSym];
+    if (map.has(flag)) return map.get(flag);
+    const newFn = cloneStore(
+      flag,
+      useStore
+    );
+    map.set(flag, newFn);
+    return useFn(view);
+  });
+  const mixinObj = {
+    ctor() {
+      if (!rootViewPath) {
+        const owner = this["owner"];
+        rootViewPath = owner?.["path"] || "";
+      }
+      this[flagSym] = getFlag(this);
+    }
+  };
+  return [useFn, mixinObj];
+}
+
+// src/compiler.ts
+import { parse as babelParse } from "@babel/parser";
+var SPLITTER2 = "";
+var VIEW_ID_PLACEHOLDER = "";
+function jsObjectToUrlParams(paramsStr) {
+  const trimmed = paramsStr.trim();
+  if (!/^[{[]/.test(trimmed) && /=/.test(trimmed)) {
+    return trimmed;
+  }
+  const objMatch = trimmed.match(/^\{(.*)\}$/s);
+  if (objMatch) {
+    const inner = objMatch[1];
+    const pairs = [];
+    const pairRegex = /(\w+)\s*:\s*(?:'([^']*)'|"([^"]*)"|([^,}]+))/g;
+    let m;
+    while ((m = pairRegex.exec(inner)) !== null) {
+      const key = m[1];
+      const value = m[2] ?? m[3] ?? m[4]?.trim() ?? "";
+      pairs.push(`${key}=${value}`);
+    }
+    return pairs.join("&");
+  }
+  return trimmed;
+}
+function protectComments(source) {
+  const comments = [];
+  const protectedSource = source.replace(/<!--[\s\S]*?-->/g, (match) => {
+    comments.push(match);
+    return `__lark_comment_${comments.length - 1}__`;
+  });
+  return { protectedSource, comments };
+}
+function restoreComments(source, comments) {
+  return source.replace(/__lark_comment_(\d+)__/g, (_, index) => {
+    return comments[parseInt(index, 10)];
+  });
+}
+function processLarkEvents(source) {
+  return source.replace(
+    /lark-(\w+)="([^"]+)"/g,
+    (fullAttr, eventName, attrValue) => {
+      const eventMatch = attrValue.match(/^(\w+)\((.*)\)$/s);
+      if (!eventMatch) return fullAttr;
+      const handlerName = eventMatch[1];
+      const paramsStr = eventMatch[2].trim();
+      if (!paramsStr) {
+        return `lark-${eventName}="${VIEW_ID_PLACEHOLDER}${SPLITTER2}${handlerName}()"`;
+      }
+      const urlParams = jsObjectToUrlParams(paramsStr);
+      return `lark-${eventName}="${VIEW_ID_PLACEHOLDER}${SPLITTER2}${handlerName}(${urlParams})"`;
+    }
+  );
+}
+function addLineMarkers(source) {
+  const lines = source.split(/\r\n?|\n/);
+  const result = [];
+  let lineNo = 0;
+  const openTag = "{{";
+  for (const line of lines) {
+    const parts = line.split(openTag);
+    if (parts.length > 1) {
+      const reconstructed = parts.map((part, i) => {
+        if (i === 0) return part;
+        return openTag + SPLITTER2 + ++lineNo;
+      }).join("");
+      result.push(reconstructed);
+    } else {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+function extractArtInfo(art) {
+  const m = art.match(new RegExp(`^${SPLITTER2}(\\d+)([\\s\\S]+)`));
+  if (m) {
+    let code = m[2].trimStart();
+    if (code.startsWith("if(")) {
+      code = code.substring(0, 2) + " " + code.substring(2);
+    } else if (code.startsWith("for(")) {
+      code = code.substring(0, 3) + " " + code.substring(3);
+    }
+    return { line: parseInt(m[1], 10), art: code };
+  }
+  return null;
+}
+function convertArtSyntax(source, debug) {
+  const markedSource = debug ? addLineMarkers(source) : source;
+  const openTag = "{{";
+  const parts = markedSource.split(openTag);
+  const result = [parts[0]];
+  const blockStack = [];
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    const closeIdx = findCloseBrace(part);
+    if (closeIdx === -1) {
+      result.push(openTag + part);
+      continue;
+    }
+    const code = part.substring(0, closeIdx);
+    const rest = part.substring(closeIdx + 2);
+    let lineNo = -1;
+    let cleanCode = code;
+    if (debug) {
+      const info = extractArtInfo(code);
+      if (info) {
+        lineNo = info.line;
+        cleanCode = info.art;
+      }
+    } else {
+      cleanCode = code.trim();
+    }
+    const converted = convertArtExpression(
+      cleanCode,
+      debug,
+      lineNo,
+      blockStack
+    );
+    result.push(converted);
+    result.push(rest);
+  }
+  if (blockStack.length > 0) {
+    const unclosed = blockStack.map((b) => `"${b.ctrl}" at line ${b.line}`).join(", ");
+    throw new Error(`[Lark Error(tmpl-art)] unclosed block(s): ${unclosed}`);
+  }
+  return result.join("");
+}
+function findCloseBrace(str) {
+  let leftCount = 0;
+  let rightCount = 0;
+  let maybeCount = 0;
+  let maybeAt = -1;
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charAt(i);
+    if (c !== "}") {
+      if (maybeCount >= 2 && maybeAt === -1) {
+        maybeAt = i;
+      }
+      maybeCount = 0;
+      rightCount = 0;
+    }
+    if (c === "{") {
+      leftCount++;
+    } else if (c === "}") {
+      maybeCount++;
+      if (!leftCount) {
+        rightCount++;
+        if (rightCount === 2) {
+          return i - 1;
+        }
+      } else {
+        leftCount--;
+      }
+    }
+  }
+  if (!leftCount && maybeCount >= 2 && maybeAt === -1) {
+    maybeAt = str.length - 2;
+  }
+  if (maybeAt > -1) {
+    return maybeAt - 2;
+  }
+  return -1;
+}
+function trimOuterParens(expr) {
+  expr = expr.trim();
+  while (expr.startsWith("(") && expr.endsWith(")")) {
+    let depth = 0;
+    let matched = true;
+    for (let i = 0; i < expr.length - 1; i++) {
+      const c = expr.charAt(i);
+      if (c === "(") depth++;
+      else if (c === ")") depth--;
+      if (depth === 0 && i < expr.length - 1) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched) break;
+    expr = expr.substring(1, expr.length - 1).trim();
+  }
+  return expr;
+}
+function convertArtExpression(code, debug, lineNo, blockStack = []) {
+  code = code.trim();
+  const debugPrefix = debug && lineNo > -1 ? `<%'${lineNo}${code.replace(/\\|'/g, "\\$&").replace(/\r\n?|\n/g, "\\n")}'%>` : "";
+  const ifForMatch = code.match(/^\s*(if|for)\s*\(/);
+  if (ifForMatch) {
+    const keyword2 = ifForMatch[1];
+    const expr = code.substring(ifForMatch[0].length);
+    if (keyword2 === "if") {
+      blockStack.push({ ctrl: "if", line: lineNo });
+      const rawExpr = expr.replace(/\)\s*$/, "");
+      const cleanExpr = trimOuterParens(rawExpr);
+      return `${debugPrefix}<%if(${cleanExpr}){%>`;
+    }
+    blockStack.push({ ctrl: "for", line: lineNo });
+    const forExpr = expr.replace(/\)\s*$/, "");
+    return `${debugPrefix}<%for(${forExpr}){%>`;
+  }
+  const tokens = code.split(/\s+/);
+  const keyword = tokens.shift();
+  switch (keyword) {
+    case "if": {
+      blockStack.push({ ctrl: "if", line: lineNo });
+      const rawExpr = tokens.join(" ").trim();
+      const expr = trimOuterParens(rawExpr);
+      return `${debugPrefix}<%if(${expr}){%>`;
+    }
+    case "else": {
+      if (tokens[0] === "if") {
+        tokens.shift();
+        const rawExpr = tokens.join(" ").trim();
+        const expr = trimOuterParens(rawExpr);
+        return `${debugPrefix}<%}else if(${expr}){%>`;
+      }
+      return `${debugPrefix}<%}else{%>`;
+    }
+    case "each": {
+      blockStack.push({ ctrl: "each", line: lineNo });
+      const object = tokens[0];
+      if (tokens.length > 1 && tokens[1] !== "as") {
+        throw new Error(
+          `[Lark Error(tmpl-art)] bad each syntax: {{${code}}}. Expected "as" keyword, got "${tokens[1]}". Usage: {{each list as item [index]}}`
+        );
+      }
+      const restTokens = tokens.slice(2);
+      const asValue = restTokens.join(" ");
+      const asExpr = parseAsExpr(asValue);
+      const index = asExpr.key || "_i";
+      const refObj = /[.[\]]/.test(object) ? `_art_obj_${object.replace(/[^\w]/g, "_")}` : object;
+      const refExpr = /[.[\]]/.test(object) ? `,${refObj}=${object}` : "";
+      const refObjCount = "_l";
+      const valueDecl = asExpr.vars ? `let ${asExpr.vars}=${refObj}[${index}]` : "";
+      let firstAndLast = "";
+      let lastCount = "";
+      if (asExpr.first) {
+        firstAndLast += `let ${asExpr.first}=${index}===0;`;
+      }
+      if (asExpr.last) {
+        lastCount = `,_lc=${refObjCount}-1`;
+        firstAndLast += `let ${asExpr.last}=${index}===_lc;`;
+      }
+      return `${debugPrefix}<%for(let ${index}=0${refExpr},${refObjCount}=${refObj}.length${lastCount};${index}<${refObjCount};${index}++){${firstAndLast}${valueDecl}%>`;
+    }
+    case "forin": {
+      blockStack.push({ ctrl: "forin", line: lineNo });
+      const object = tokens[0];
+      if (tokens.length > 1 && tokens[1] !== "as") {
+        throw new Error(
+          `[Lark Error(tmpl-art)] bad forin syntax: {{${code}}}. Expected "as" keyword, got "${tokens[1]}". Usage: {{forin obj as val [key]}}`
+        );
+      }
+      const restTokens2 = tokens.slice(2);
+      const asValue2 = restTokens2.join(" ");
+      const asExpr2 = parseAsExpr(asValue2);
+      const key1 = asExpr2.key || "_k";
+      const refObj2 = /[.[\]]/.test(object) ? `_art_obj_${object.replace(/[^\w]/g, "_")}` : object;
+      const refExpr2 = /[.[\]]/.test(object) ? `let ${refObj2}=${object};` : "";
+      const valueDecl2 = asExpr2.vars ? `let ${asExpr2.vars}=${refObj2}[${key1}]` : "";
+      return `${debugPrefix}<%${refExpr2}for(let ${key1} in ${refObj2}){${valueDecl2}%>`;
+    }
+    case "for": {
+      blockStack.push({ ctrl: "for", line: lineNo });
+      const expr = tokens.join(" ").trim();
+      return `${debugPrefix}<%for(${expr}){%>`;
+    }
+    case "set":
+      return `${debugPrefix}<%let ${tokens.join(" ")};%>`;
+    case "/if":
+    case "/each":
+    case "/forin":
+    case "/for": {
+      const expectedCtrl = keyword.substring(1);
+      const last = blockStack.pop();
+      if (!last) {
+        throw new Error(
+          `[Lark Error(tmpl-art)] unexpected {{${code}}}: no matching open block`
+        );
+      }
+      if (last.ctrl !== expectedCtrl) {
+        throw new Error(
+          `[Lark Error(tmpl-art)] unexpected {{${code}}}: expected {{/${last.ctrl}}} to close block opened at line ${last.line}`
+        );
+      }
+      return `${debugPrefix}<%}%>`;
+    }
+    default:
+      return `${debugPrefix}<%${code}%>`;
+  }
+}
+function parseAsExpr(expr) {
+  expr = expr.trim();
+  if (!expr) {
+    return { vars: "", key: "", last: "", first: "", bad: false };
+  }
+  if (expr.startsWith("{") || expr.startsWith("[")) {
+    const stack = [];
+    let vars = "";
+    let key = "";
+    let last = "";
+    let first = "";
+    let pos = 0;
+    let bad = false;
+    for (const c of expr) {
+      if (pos === 0) vars += c;
+      else if (pos === 1) key += c;
+      else if (pos === 2) last += c;
+      else if (pos === 3) first += c;
+      if (c === "{" || c === "[") stack.push(c);
+      else if (c === "}") {
+        if (stack[stack.length - 1] === "{") stack.pop();
+        else {
+          bad = true;
+          break;
+        }
+      } else if (c === "]") {
+        if (stack[stack.length - 1] === "[") stack.pop();
+        else {
+          bad = true;
+          break;
+        }
+      } else if (c === " " && !stack.length) {
+        pos++;
+      }
+    }
+    return {
+      vars: vars.trim(),
+      key: key.trim(),
+      last: last.trim(),
+      first: first.trim(),
+      bad: bad || stack.length > 0
+    };
+  }
+  const parts = expr.split(/\s+/);
+  return {
+    vars: parts[0] || "",
+    key: parts[1] || "",
+    last: parts[2] || "",
+    first: parts[3] || "",
+    bad: false
+  };
+}
+function compileToFunction(source, debug, file) {
+  const matcher = /<%([@=!:])?([\s\S]*?)%>|$/g;
+  let index = 0;
+  let funcSource = `$p+='`;
+  let hasAtRule = false;
+  const escapeSlashRegExp = /\\|'/g;
+  const escapeBreakReturnRegExp = /\r|\n/g;
+  source.replace(matcher, (match, operate, content, offset) => {
+    funcSource += source.substring(index, offset).replace(escapeSlashRegExp, "\\$&").replace(escapeBreakReturnRegExp, "\\n");
+    index = offset + match.length;
+    if (debug) {
+      let expr = source.substring(
+        index - match.length + 2 + (operate ? 1 : 0),
+        index - 2
+      );
+      const x11 = String.fromCharCode(17);
+      const artReg = new RegExp(`^'(\\d+)${x11}([^${x11}]+)${x11}'$`);
+      const artM = expr.match(artReg);
+      let art = "";
+      let line = -1;
+      if (artM) {
+        expr = expr.replace(artReg, "");
+        art = artM[2];
+        line = parseInt(artM[1], 10);
+      } else {
+        expr = expr.replace(escapeSlashRegExp, "\\$&").replace(escapeBreakReturnRegExp, "\\n");
+      }
+      if (operate === "@") {
+        hasAtRule = true;
+        funcSource += `'+($expr='<%${operate + expr}%>',$i($$ref,${content}))+'`;
+      } else if (operate === "=" || operate === ":") {
+        funcSource += `'+($expr='<%${operate + expr}%>',$e(${content}))+'`;
+      } else if (operate === "!") {
+        if (!content.startsWith("$eu(") || !content.endsWith(")")) {
+          content = `$n(${content})`;
+        }
+        funcSource += `'+($expr='<%${operate + expr}%>',${content})+'`;
+      } else if (content) {
+        if (line > -1) {
+          funcSource += `';$line=${line};$art='${art}';`;
+          content = "";
+        } else {
+          funcSource += `';`;
+        }
+        if (funcSource.endsWith(`+'';`)) {
+          funcSource = funcSource.substring(0, funcSource.length - 4) + ";";
+        }
+        if (expr) {
+          funcSource += `$expr='<%${expr}%>';`;
+        }
+        funcSource += content + `;$p+='`;
+      }
+    } else {
+      if (operate === "@") {
+        hasAtRule = true;
+        funcSource += `'+$i($$ref,${content})+'`;
+      } else if (operate === "=" || operate === ":") {
+        funcSource += `'+$e(${content})+'`;
+      } else if (operate === "!") {
+        if (!content.startsWith("$eu(") || !content.endsWith(")")) {
+          content = `$n(${content})`;
+        }
+        funcSource += `'+${content}+'`;
+      } else if (content) {
+        funcSource += `';`;
+        if (funcSource.endsWith(`+'';`)) {
+          funcSource = funcSource.substring(0, funcSource.length - 4) + ";";
+        }
+        funcSource += `${content};$p+='`;
+      }
+    }
+    return match;
+  });
+  funcSource += `';`;
+  funcSource = funcSource.replace(/\$p\+='';/g, "");
+  funcSource = funcSource.replace(/\$p\+=''\+/g, "$p+=");
+  if (debug) {
+    const filePart = file ? `\\r\\n\\tat file:${file}` : "";
+    funcSource = `let $expr,$art,$line;try{${funcSource}}catch(ex){let msg='render view error:'+(ex.message||ex);if($art)msg+='\\r\\n\\tsrc art:{{'+$art+'}}\\r\\n\\tat line:'+$line;msg+='\\r\\n\\t'+($art?'translate to:':'expr:');msg+=$expr+'${filePart}';throw msg;}`;
+  }
+  const viewIdReg = new RegExp(String.fromCharCode(31), "g");
+  funcSource = funcSource.replace(viewIdReg, `'+$viewId+'`);
+  const atRule = hasAtRule ? `if(!$i){$i=(ref,v,k,f)=>{for(f=ref[$g];--f;)if(ref[k=$g+f]===v)return k;ref[k=$g+ref[$g]++]=v;return k;}}` : "";
+  const encode = `if(!$n){let $em={'&':'amp','<':'lt','>':'gt','"':'#34','\\'':'#39','\`':'#96'},$er=/[&<>"'\`]/g,$ef=m=>'&'+$em[m]+';';$n=v=>''+(v==null?'':v);$e=v=>$n(v).replace($er,$ef)}`;
+  const encodeURIMore = `if(!$eu){let $um={'!':'%21','\\'':'%27','(':'%28',')':'%29','*':'%2A'},$uf=m=>$um[m],$uq=/[!')(*]/g;$eu=v=>encodeURIComponent($n(v)).replace($uq,$uf)}`;
+  const encodeQuote = `if(!$eq){let $qr=/['"\\\\]/g;$eq=v=>$n(v).replace($qr,'\\\\$&')}`;
+  const refFallback = "if(!$$ref)$$ref=$$;";
+  const fns = `${refFallback}${encode}${encodeURIMore}${encodeQuote}${atRule};`;
+  const fullSource = `${fns}let $g='\\x1e',$_temp,$p=''{{VARS}};${funcSource}return $p`;
+  return `($$,$viewId,$$ref,$e,$n,$eu,$i,$eq)=>{${fullSource}}`;
+}
+function compileTemplate(source, options = {}) {
+  const { debug = false, globalVars = [], file } = options;
+  const { protectedSource, comments } = protectComments(source);
+  const converted = convertArtSyntax(protectedSource, debug);
+  const larkEventProcessed = processLarkEvents(converted);
+  const finalSource = restoreComments(larkEventProcessed, comments);
+  const funcBody = compileToFunction(finalSource, debug, file);
+  const varDeclarations = globalVars.map((key) => `,${key}=$$.${key}`).join("");
+  const funcWithVars = funcBody.replace("{{VARS}}", () => varDeclarations);
+  return `export default function(data, selfId, refData) {
+  let $$ = data || {},
+      $viewId = selfId || '';
+  return (${funcWithVars})($$, $viewId, refData,
+    /* $e */ v => String(v == null ? '' : v).replace(/[&<>"'\`]/g, m => '&' + ({'&':'amp','<':'lt','>':'gt','"':'#34',"'":'#39','\`':'#96'})[m] + ';'),
+    /* $n */ v => String(v == null ? '' : v),
+    /* $eu */ null,
+    /* $i */ null,
+    /* $eq */ null
+  );
+}`;
+}
+function extractGlobalVars(source) {
+  const { protectedSource, comments: _comments } = protectComments(source);
+  const larkEventProcessed = processLarkEvents(protectedSource);
+  const converted = convertArtSyntax(larkEventProcessed, false);
+  const tmpl = restoreComments(converted, _comments);
+  const tmplCmdReg = /<%([@=!:])?([\s\S]*?)%>|$/g;
+  const fnParts = [];
+  const htmlStore = {};
+  let htmlIndex = 0;
+  let lastIndex = 0;
+  const htmlKey = "";
+  tmpl.replace(
+    tmplCmdReg,
+    (match, operate, content, offset) => {
+      const start = operate ? 3 : 2;
+      const htmlText = tmpl.substring(lastIndex, offset + start);
+      const key = htmlKey + htmlIndex++ + htmlKey;
+      htmlStore[key] = htmlText;
+      lastIndex = offset + match.length - 2;
+      if (operate && content.trim()) {
+        fnParts.push(';"' + key + '";', "[" + content + "]");
+      } else {
+        fnParts.push(';"' + key + '";', content || "");
+      }
+      return match;
+    }
+  );
+  let fn = fnParts.join("");
+  fn = `(function(){${fn}})`;
+  let ast;
+  try {
+    ast = babelParse(fn, {
+      sourceType: "script",
+      allowReturnOutsideFunction: true,
+      allowAwaitOutsideFunction: true
+    });
+  } catch {
+    return fallbackExtractVariables(source);
+  }
+  const globalExists = { ...BUILTIN_GLOBALS };
+  const globalVars = /* @__PURE__ */ Object.create(null);
+  const fnRange = [];
+  walkAst(ast, {
+    VariableDeclarator(node) {
+      if (node.id.type === "Identifier") {
+        const name = node.id.name;
+        globalExists[name] = node.init ? 3 : 2;
+      }
+    },
+    FunctionDeclaration(node) {
+      if (node.id) {
+        globalExists[node.id.name] = 3;
+      }
+      fnRange.push(node);
+    },
+    FunctionExpression(node) {
+      fnRange.push(node);
+    },
+    ArrowFunctionExpression(node) {
+      fnRange.push(node);
+    },
+    CallExpression(node) {
+      if (node.callee.type === "Identifier") {
+        globalExists[node.callee.name] = 1;
+      }
+    }
+  });
+  const functionParams = /* @__PURE__ */ Object.create(null);
+  for (const fnNode of fnRange) {
+    const params = "params" in fnNode ? fnNode.params : [];
+    for (const p of params) {
+      if (p.type === "Identifier") {
+        functionParams[p.name] = 1;
+      } else if (p.type === "AssignmentPattern" && p.left.type === "Identifier") {
+        functionParams[p.left.name] = 1;
+      } else if (p.type === "RestElement" && p.argument.type === "Identifier") {
+        functionParams[p.argument.name] = 1;
+      }
+    }
+  }
+  walkAst(ast, {
+    Identifier(node) {
+      const name = node.name;
+      if (globalExists[name]) return;
+      if (functionParams[name]) return;
+      globalVars[name] = 1;
+    },
+    AssignmentExpression(node) {
+      if (node.left.type === "Identifier") {
+        const name = node.left.name;
+        if (!globalExists[name] || globalExists[name] === 1) {
+          globalExists[name] = (globalExists[name] || 0) + 1;
+        }
+      }
+    }
+  });
+  return Object.keys(globalVars);
+}
+function fallbackExtractVariables(source) {
+  const vars = /* @__PURE__ */ new Set();
+  const outputReg = /\{\{[:=!@]\s*([a-zA-Z_$][\w$]*)[^}]*\}\}/g;
+  let m;
+  while ((m = outputReg.exec(source)) !== null) {
+    vars.add(m[1]);
+  }
+  const eachReg = /\{\{each\s+([a-zA-Z_$][\w$]*)\s+as/g;
+  while ((m = eachReg.exec(source)) !== null) {
+    vars.add(m[1]);
+  }
+  const ifReg = /\{\{(?:else\s+)?if\s+([a-zA-Z_$][\w$]*)[^}]*\}\}/g;
+  while ((m = ifReg.exec(source)) !== null) {
+    vars.add(m[1]);
+  }
+  return Array.from(vars).filter((v) => !BUILTIN_GLOBAL_SET.has(v));
+}
+function walkAst(ast, visitors) {
+  function visit(node) {
+    const type = node.type;
+    if (visitors[type]) {
+      visitors[type](node);
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range")
+        continue;
+      if (type === "MemberExpression" && key === "property" && !node.computed)
+        continue;
+      if (type === "ObjectProperty" && key === "key" && !node.computed) {
+        continue;
+      }
+      if (type === "ObjectMethod" && key === "key" && !node.computed) {
+        continue;
+      }
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && typeof item.type === "string") {
+            visit(item);
+          }
+        }
+      } else if (child && typeof child === "object" && typeof child.type === "string") {
+        visit(child);
+      }
+    }
+  }
+  visit(ast);
+}
+var BUILTIN_GLOBALS = {
+  // ─── Template runtime helpers (injected by compileToFunction) ───────
+  //
+  // These variables appear in the generated template function signature
+  // or body. They must be excluded from extractGlobalVars() so that
+  // they are not mistaken for user data variables and destructured from $$.
+  // SPLITTER character constant (same as \x1e), used as namespace separator
+  // for refData keys, event attribute encoding, and internal data structures.
+  // Declared as: let $g='\x1e'
+  $g: 1,
+  // refData — the data object passed from Updater to the template function.
+  // User variables are destructured from $$ at the top of the function:
+  //   let {name, age} = $$;
+  // This is the first parameter of the generated arrow function.
+  $$: 1,
+  // Null-safe toString: v => '' + (v == null ? '' : v)
+  // Converts null/undefined to empty string, otherwise calls toString().
+  // Wraps every {{!raw}} output to prevent "null" / "undefined" rendering.
+  $n: 1,
+  // HTML entity encoder: v => $n(v).replace(/[&<>"'`]/g, entityMap)
+  // Encodes &, <, >, ", ', ` to HTML entities (&amp; &lt; etc.)
+  // Applied to all {{=escaped}} and {{:binding}} outputs.
+  $e: 1,
+  // HTML entity map — internal object used by $e:
+  //   {'&':'amp','<':'gt','>':'gt','"':'#34','\'':'#39','`':'#96'}
+  // Not a standalone function; referenced inside $e's closure.
+  $em: 1,
+  // HTML entity RegExp — internal regex used by $e:
+  //   /[&<>"'`]/g
+  $er: 1,
+  // HTML entity replacer function — internal helper used by $e:
+  //   m => '&' + $em[m] + ';'
+  // Maps each matched character to its entity string.
+  $ef: 1,
+  // Output buffer — the string accumulator for rendered HTML.
+  // All template output is appended via $p += '...'.
+  // Declared as: let $p = ''
+  $p: 1,
+  // Reference lookup: (refData, value) => key
+  // Finds or allocates a SPLITTER-prefixed key in refData for a given
+  // object reference. Used by {{@ref}} operator for passing object
+  // references to child views via lark-view attributes.
+  // Aligned with mx.js Updater_Ref.
+  $i: 1,
+  // URI encoder: v => encodeURIComponent($n(v)).replace(/[!')(*]/g, extraMap)
+  // Extends encodeURIComponent with encoding of ! ' ( ) *.
+  // Applied to values in lark-event URL parameters and {{!uri}} contexts.
+  $eu: 1,
+  // Quote encoder: v => $n(v).replace(/['"\\]/g, '\\$&')
+  // Escapes quotes and backslashes for safe embedding in HTML attribute
+  // values (e.g. data-json='...').
+  $eq: 1,
+  // View ID — the unique identifier of the owning View instance.
+  // Injected into lark-event attribute values at render time so that
+  // EventDelegator can dispatch events to the correct View handler.
+  // The \x1f placeholder in compiled output is replaced with '+$viewId+'.
+  $viewId: 1,
+  // Debug: current expression text — stores the template expression being
+  // evaluated, for error reporting. Only present in debug mode.
+  // e.g. $expr='<%=user.name%>'
+  $expr: 1,
+  // Debug: original art syntax — stores the {{}} template syntax before
+  // conversion, for error reporting. Only present in debug mode.
+  // e.g. $art='{{=user.name}}'
+  $art: 1,
+  // Debug: source line number — tracks the current line in the template
+  // source, for error reporting. Only present in debug mode.
+  $line: 1,
+  // refData alias — fallback reference lookup table.
+  // Defaults to $$ when no explicit $$ref is provided.
+  // Ensures $i() does not crash when @ operator is used without refData.
+  $$ref: 1,
+  // Temporary variable — used by the compiler for intermediate
+  // expression results in generated code (e.g. loop variables,
+  // conditional branches). Declared as: let $_temp
+  $_temp: 1,
+  // JS literals
+  undefined: 1,
+  null: 1,
+  true: 1,
+  false: 1,
+  NaN: 1,
+  Infinity: 1,
+  // JS built-in globals
+  window: 1,
+  self: 1,
+  globalThis: 1,
+  document: 1,
+  console: 1,
+  JSON: 1,
+  Math: 1,
+  Intl: 1,
+  Promise: 1,
+  Symbol: 1,
+  Number: 1,
+  String: 1,
+  Boolean: 1,
+  Array: 1,
+  Object: 1,
+  Date: 1,
+  RegExp: 1,
+  Error: 1,
+  TypeError: 1,
+  RangeError: 1,
+  SyntaxError: 1,
+  Map: 1,
+  Set: 1,
+  WeakMap: 1,
+  WeakSet: 1,
+  Proxy: 1,
+  Reflect: 1,
+  ArrayBuffer: 1,
+  DataView: 1,
+  Float32Array: 1,
+  Float64Array: 1,
+  Int8Array: 1,
+  Int16Array: 1,
+  Int32Array: 1,
+  Uint8Array: 1,
+  Uint16Array: 1,
+  Uint32Array: 1,
+  Uint8ClampedArray: 1,
+  // Functions
+  parseInt: 1,
+  parseFloat: 1,
+  isNaN: 1,
+  isFinite: 1,
+  encodeURIComponent: 1,
+  decodeURIComponent: 1,
+  encodeURI: 1,
+  decodeURI: 1,
+  // Babel helpers
+  arguments: 1,
+  this: 1,
+  require: 1,
+  // Lark framework
+  Lark: 1
+};
+var BUILTIN_GLOBAL_SET = new Set(Object.keys(BUILTIN_GLOBALS));
+export {
+  Bag,
+  CALL_BREAK_TIME,
+  Cache,
+  EVT_METHOD_REG,
+  EventDelegator,
+  EventEmitter,
+  Frame,
+  Framework,
+  LARK_VIEW,
+  Platform,
+  ROUTER_EVENTS,
+  Router,
+  SPLITTER,
+  Service,
+  State,
+  TAG_ATTR_KEY,
+  TAG_KEY,
+  TAG_NAME_REGEX,
+  TAG_VIEW_KEY,
+  Updater,
+  VIEW_EVT_METHOD_REG,
+  View,
+  applyIdUpdates,
+  applyStyle,
+  applyVdomOps,
+  assign,
+  cell,
+  classExtend,
+  cloneData,
+  cloneStore,
+  compileTemplate,
+  createState,
+  createVdomRef,
+  defineStore,
+  delStore,
+  encodeHTML,
+  encodeQ,
+  encodeSafe,
+  encodeURIExtra,
+  ensureElementId,
+  extractGlobalVars,
+  funcWithTry,
+  generateId,
+  getAttribute,
+  getById,
+  getPlatform,
+  getStore,
+  getUseStore,
+  has,
+  isArray,
+  isPlainObject,
+  isPrimitive,
+  isPrimitiveOrFunc,
+  isState,
+  isStoreActive,
+  keys,
+  lazySet,
+  mark,
+  markBooted,
+  markRouterBooted,
+  multi,
+  nextCounter,
+  nodeInside,
+  noop,
+  now,
+  observeCell,
+  parseUri,
+  registerViewClass,
+  safeguard,
+  setData,
+  shallowSet,
+  mark2 as storeMark,
+  unmark2 as storeUnmark,
+  syncCounter,
+  toMap,
+  toUri,
+  translateData,
+  unmark,
+  vdomGetCompareKey,
+  vdomGetNode,
+  vdomSetAttributes,
+  vdomSetChildNodes,
+  vdomSetNode,
+  vdomSpecialDiff,
+  vdomUnmountFrames
+};