@weapp-vite/web 0.0.2

package/dist/runtime/index.mjs

@@ -0,0 +1,1115 @@
+// src/runtime/component.ts
+var EVENT_TO_DOM = {
+  tap: "click",
+  input: "input",
+  change: "change",
+  submit: "submit",
+  blur: "blur",
+  focus: "focus"
+};
+function hyphenate(name) {
+  return name.replace(/([A-Z])/g, (_, char) => `-${char.toLowerCase()}`);
+}
+function toCamelCase(name) {
+  return name.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function cloneValue(value) {
+  if (Array.isArray(value)) {
+    return value.slice();
+  }
+  if (value && typeof value === "object") {
+    return { ...value };
+  }
+  return value;
+}
+function coerceValue(value, type) {
+  if (type === Boolean) {
+    if (value === "" || value === true) {
+      return true;
+    }
+    if (value === void 0 || value === null || value === false) {
+      return false;
+    }
+    if (typeof value === "string") {
+      return value !== "false";
+    }
+    return Boolean(value);
+  }
+  if (type === Number) {
+    if (value === void 0 || value === null) {
+      return value;
+    }
+    const numeric = Number(value);
+    return Number.isNaN(numeric) ? value : numeric;
+  }
+  if (type === Object || type === Array) {
+    if (value === void 0 || value === null) {
+      return value;
+    }
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+  return value;
+}
+function bindRuntimeEvents(root, methods, instance) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+  while (walker.nextNode()) {
+    const element = walker.currentNode;
+    for (const attribute of element.getAttributeNames()) {
+      if (!attribute.startsWith("data-wx-on-")) {
+        continue;
+      }
+      const handlerName = element.getAttribute(attribute);
+      if (!handlerName) {
+        continue;
+      }
+      const eventName = attribute.slice("data-wx-on-".length);
+      const handler = methods[handlerName];
+      if (!handler) {
+        continue;
+      }
+      const domEvent = EVENT_TO_DOM[eventName] ?? eventName;
+      element.addEventListener(domEvent, (nativeEvent) => {
+        const dataset = { ...element.dataset };
+        const syntheticEvent = {
+          type: eventName,
+          timeStamp: nativeEvent.timeStamp,
+          detail: nativeEvent.detail ?? nativeEvent.data ?? void 0,
+          target: {
+            dataset
+          },
+          currentTarget: {
+            dataset
+          },
+          originalEvent: nativeEvent
+        };
+        handler.call(instance, syntheticEvent);
+      });
+    }
+  }
+}
+function defineComponent(tagName, options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("[@weapp-vite/web] defineComponent \u9700\u8981\u63D0\u4F9B\u914D\u7F6E\u5BF9\u8C61\u3002");
+  }
+  if (customElements.get(tagName)) {
+    return customElements.get(tagName);
+  }
+  const { template, style = "", component = {} } = options;
+  if (!template) {
+    throw new Error("[@weapp-vite/web] defineComponent \u9700\u8981\u63D0\u4F9B\u6A21\u677F\u6E32\u67D3\u51FD\u6570\u3002");
+  }
+  const propertyEntries = Object.entries(component.properties ?? {});
+  const observedAttributes = propertyEntries.map(([name]) => hyphenate(name));
+  const defaultPropertyValues = propertyEntries.reduce((acc, [name, prop]) => {
+    if (Object.prototype.hasOwnProperty.call(prop, "value")) {
+      acc[name] = cloneValue(prop.value);
+    } else {
+      acc[name] = void 0;
+    }
+    return acc;
+  }, {});
+  const lifetimes = component.lifetimes ?? {};
+  class WeappWebComponent extends HTMLElement {
+    static get observedAttributes() {
+      return observedAttributes;
+    }
+    #state;
+    #properties;
+    #methods;
+    #shadow;
+    #contentRoot;
+    #styleElement;
+    #isMounted = false;
+    constructor() {
+      super();
+      const dataOption = typeof component.data === "function" ? component.data() : component.data ?? {};
+      this.#properties = { ...defaultPropertyValues };
+      this.#state = { ...cloneValue(this.#properties), ...cloneValue(dataOption) };
+      this.#shadow = this.attachShadow({ mode: "open" });
+      if (style) {
+        this.#styleElement = document.createElement("style");
+        this.#styleElement.textContent = style;
+        this.#shadow.append(this.#styleElement);
+      }
+      this.#contentRoot = document.createElement("div");
+      this.#contentRoot.setAttribute("part", "content");
+      this.#shadow.append(this.#contentRoot);
+      this.#methods = {};
+      for (const [name, fn] of Object.entries(component.methods ?? {})) {
+        if (typeof fn === "function") {
+          this.#methods[name] = fn.bind(this);
+        }
+      }
+      for (const [propName] of propertyEntries) {
+        Object.defineProperty(this, propName, {
+          configurable: true,
+          enumerable: true,
+          get: () => this.#state[propName],
+          set: (value) => {
+            this.#setProperty(propName, value);
+          }
+        });
+      }
+      lifetimes.created?.call(this);
+    }
+    get data() {
+      return this.#state;
+    }
+    get properties() {
+      return this.#properties;
+    }
+    setData(patch) {
+      this.#applyDataPatch(patch);
+    }
+    triggerEvent(name, detail) {
+      this.dispatchEvent(new CustomEvent(name, {
+        detail,
+        bubbles: true,
+        composed: true
+      }));
+    }
+    connectedCallback() {
+      this.#applyAttributes();
+      this.#render();
+      lifetimes.attached?.call(this);
+      this.#isMounted = true;
+      lifetimes.ready?.call(this);
+    }
+    disconnectedCallback() {
+      this.#isMounted = false;
+      lifetimes.detached?.call(this);
+    }
+    attributeChangedCallback(attrName, _oldValue, newValue) {
+      const propName = toCamelCase(attrName);
+      if (!Object.prototype.hasOwnProperty.call(this.#properties, propName)) {
+        return;
+      }
+      const propOption = component.properties?.[propName];
+      const coerced = coerceValue(newValue, propOption?.type);
+      this.#setProperty(propName, coerced);
+    }
+    #applyAttributes() {
+      for (const attr of this.attributes) {
+        this.attributeChangedCallback(attr.name, null, attr.value);
+      }
+    }
+    #applyDataPatch(patch) {
+      if (!patch || typeof patch !== "object") {
+        return;
+      }
+      let changed = false;
+      for (const [key, value] of Object.entries(patch)) {
+        if (this.#state[key] !== value) {
+          const oldValue = this.#state[key];
+          this.#state[key] = value;
+          if (Object.prototype.hasOwnProperty.call(this.#properties, key)) {
+            this.#properties[key] = value;
+            component.properties?.[key]?.observer?.call(this, value, oldValue);
+          }
+          changed = true;
+        }
+      }
+      if (changed) {
+        this.#render();
+      }
+    }
+    #setProperty(name, value) {
+      const propOption = component.properties?.[name];
+      const coerced = coerceValue(value, propOption?.type);
+      const oldValue = this.#properties[name];
+      if (oldValue === coerced) {
+        return;
+      }
+      this.#properties[name] = coerced;
+      this.#state[name] = coerced;
+      if (this.#isMounted) {
+        this.#render();
+      }
+      propOption?.observer?.call(this, coerced, oldValue);
+    }
+    #render() {
+      const html = template(this.#state);
+      if (!this.#contentRoot) {
+        return;
+      }
+      this.#contentRoot.innerHTML = html;
+      bindRuntimeEvents(this.#contentRoot, this.#methods, this);
+    }
+  }
+  customElements.define(tagName, WeappWebComponent);
+  return WeappWebComponent;
+}
+
+// src/runtime/polyfill.ts
+var pageRegistry = /* @__PURE__ */ new Map();
+var componentRegistry = /* @__PURE__ */ new Map();
+var navigationHistory = [];
+var pageOrder = [];
+var activeEntry;
+var appInstance;
+var appLaunched = false;
+var ROUTE_META_SYMBOL = Symbol("@weapp-vite/web:route-meta");
+var PAGE_STATE_SYMBOL = Symbol("@weapp-vite/web:page-state");
+var PAGE_LIFECYCLE_KEYS = /* @__PURE__ */ new Set(["onLoad", "onReady", "onShow", "onHide", "onUnload"]);
+var RESERVED_PAGE_METHOD_KEYS = /* @__PURE__ */ new Set([
+  "data",
+  "methods",
+  "lifetimes",
+  "properties",
+  "behaviors",
+  "options",
+  "observers",
+  "mixins",
+  ...PAGE_LIFECYCLE_KEYS
+]);
+var RESERVED_COMPONENT_METHOD_KEYS = /* @__PURE__ */ new Set([
+  "data",
+  "methods",
+  "lifetimes",
+  "properties",
+  "behaviors",
+  "options",
+  "observers",
+  "mixins"
+]);
+function slugify(id, prefix) {
+  const normalized = id.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return `${prefix}-${normalized || "index"}`;
+}
+function ensureDocumentReady(callback) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", () => callback(), { once: true });
+    return;
+  }
+  callback();
+}
+function ensureContainer() {
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  return document.querySelector("#app") ?? document.body;
+}
+function cloneLifetimes(source) {
+  if (!source) {
+    return void 0;
+  }
+  return {
+    ...source
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isMethodHandler(value) {
+  return typeof value === "function";
+}
+function normalizeMethodBag(source, reserved) {
+  const methods = {};
+  const sourceMethods = isRecord(source?.methods) ? source?.methods : void 0;
+  if (sourceMethods) {
+    for (const [key, value] of Object.entries(sourceMethods)) {
+      if (isMethodHandler(value)) {
+        methods[key] = value;
+      }
+    }
+  }
+  if (source) {
+    for (const [key, value] of Object.entries(source)) {
+      if (reserved.has(key)) {
+        continue;
+      }
+      if (isMethodHandler(value) && methods[key] === void 0) {
+        methods[key] = value;
+      }
+    }
+  }
+  return methods;
+}
+function normalizePageOptions(raw) {
+  const component = { ...raw ?? {} };
+  component.methods = normalizeMethodBag(raw, RESERVED_PAGE_METHOD_KEYS);
+  if (raw?.lifetimes) {
+    component.lifetimes = cloneLifetimes(raw.lifetimes);
+  }
+  const hooks = {};
+  if (typeof raw?.onLoad === "function") {
+    hooks.onLoad = raw.onLoad;
+  }
+  if (typeof raw?.onReady === "function") {
+    hooks.onReady = raw.onReady;
+  }
+  if (typeof raw?.onShow === "function") {
+    hooks.onShow = raw.onShow;
+  }
+  if (typeof raw?.onHide === "function") {
+    hooks.onHide = raw.onHide;
+  }
+  if (typeof raw?.onUnload === "function") {
+    hooks.onUnload = raw.onUnload;
+  }
+  return { component, hooks };
+}
+function normalizeComponentOptions(raw) {
+  const component = { ...raw ?? {} };
+  component.methods = normalizeMethodBag(raw, RESERVED_COMPONENT_METHOD_KEYS);
+  if (raw?.lifetimes) {
+    component.lifetimes = cloneLifetimes(raw.lifetimes);
+  }
+  return component;
+}
+function getRouteMeta(instance) {
+  return instance[ROUTE_META_SYMBOL];
+}
+function getPageState(instance) {
+  const target = instance;
+  target[PAGE_STATE_SYMBOL] ??= { loaded: false };
+  return target[PAGE_STATE_SYMBOL];
+}
+function ensureAppLaunched(entry) {
+  if (!appInstance || appLaunched) {
+    return;
+  }
+  const launchOptions = {
+    path: entry.id,
+    scene: 0,
+    query: entry.query,
+    referrerInfo: {}
+  };
+  if (typeof appInstance.onLaunch === "function") {
+    appInstance.onLaunch(launchOptions);
+  }
+  if (typeof appInstance.onShow === "function") {
+    appInstance.onShow(launchOptions);
+  }
+  appLaunched = true;
+}
+function mountEntry(entry) {
+  const record = pageRegistry.get(entry.id);
+  if (!record) {
+    return;
+  }
+  ensureDocumentReady(() => {
+    const container = ensureContainer();
+    if (!container) {
+      return;
+    }
+    while (container.childNodes.length) {
+      container.removeChild(container.childNodes[0]);
+    }
+    const element = document.createElement(record.tag);
+    element[ROUTE_META_SYMBOL] = {
+      id: entry.id,
+      query: entry.query,
+      entry
+    };
+    container.append(element);
+    activeEntry = entry;
+    ensureAppLaunched(entry);
+  });
+}
+function pushEntry(id, query) {
+  if (!pageRegistry.has(id)) {
+    return;
+  }
+  const entry = { id, query };
+  navigationHistory.push(entry);
+  mountEntry(entry);
+}
+function replaceEntry(id, query) {
+  if (!pageRegistry.has(id)) {
+    return;
+  }
+  const entry = { id, query };
+  if (navigationHistory.length) {
+    navigationHistory[navigationHistory.length - 1] = entry;
+  } else {
+    navigationHistory.push(entry);
+  }
+  mountEntry(entry);
+}
+function relaunchEntry(id, query) {
+  navigationHistory.length = 0;
+  pushEntry(id, query);
+}
+var PAGE_TEMPLATE_EXTENSIONS = [".wxml", ".axml", ".swan", ".ttml", ".qml", ".ksml", ".xhsml", ".html"];
+function stripTemplateExtension(id) {
+  const lowered = id.toLowerCase();
+  for (const ext of PAGE_TEMPLATE_EXTENSIONS) {
+    if (lowered.endsWith(ext)) {
+      return id.slice(0, -ext.length);
+    }
+  }
+  return id;
+}
+function parsePageId(raw) {
+  const normalized = raw.replace(/^\//, "");
+  return stripTemplateExtension(normalized);
+}
+function parsePageUrl(url) {
+  const [path, search = ""] = url.split("?");
+  const query = {};
+  if (search) {
+    const params = new URLSearchParams(search);
+    for (const [key, value] of params.entries()) {
+      query[key] = value;
+    }
+  }
+  return {
+    id: parsePageId(path || ""),
+    query
+  };
+}
+function augmentPageComponentOptions(component, record) {
+  const lifetimes = component.lifetimes ?? {};
+  const originalCreated = lifetimes?.created;
+  const originalAttached = lifetimes?.attached;
+  const originalReady = lifetimes?.ready;
+  const originalDetached = lifetimes?.detached;
+  const enhanced = {
+    ...component,
+    lifetimes: {
+      ...lifetimes,
+      created() {
+        originalCreated?.call(this);
+        getPageState(this);
+        record.instances.add(this);
+      },
+      attached() {
+        originalAttached?.call(this);
+        const meta = getRouteMeta(this);
+        if (meta?.entry) {
+          meta.entry.instance = this;
+        }
+        const state = getPageState(this);
+        if (!state.loaded) {
+          record.hooks.onLoad?.call(this, meta?.query ?? {});
+          state.loaded = true;
+        }
+        record.hooks.onShow?.call(this);
+      },
+      ready() {
+        originalReady?.call(this);
+        record.hooks.onReady?.call(this);
+      },
+      detached() {
+        originalDetached?.call(this);
+        const meta = getRouteMeta(this);
+        if (meta?.entry) {
+          meta.entry.instance = void 0;
+        }
+        record.hooks.onHide?.call(this);
+        record.hooks.onUnload?.call(this);
+        const state = getPageState(this);
+        state.loaded = false;
+        record.instances.delete(this);
+      }
+    }
+  };
+  return enhanced;
+}
+function initializePageRoutes(ids) {
+  pageOrder = Array.from(new Set(ids));
+  if (!pageOrder.length) {
+    return;
+  }
+  if (!navigationHistory.length) {
+    pushEntry(pageOrder[0], {});
+  }
+}
+function registerPage(options, meta) {
+  const tag = slugify(meta.id, "wv-page");
+  const template = meta.template ?? (() => "");
+  const normalized = normalizePageOptions(options);
+  const record = {
+    tag,
+    hooks: normalized.hooks,
+    instances: /* @__PURE__ */ new Set()
+  };
+  const component = augmentPageComponentOptions(normalized.component, record);
+  defineComponent(tag, {
+    template,
+    style: meta.style,
+    component
+  });
+  pageRegistry.set(meta.id, record);
+  return options;
+}
+function registerComponent(options, meta) {
+  const tag = slugify(meta.id, "wv-component");
+  const template = meta.template ?? (() => "");
+  const component = normalizeComponentOptions(options);
+  defineComponent(tag, {
+    template,
+    style: meta.style,
+    component
+  });
+  componentRegistry.set(meta.id, { tag });
+  return options;
+}
+function registerApp(options, _meta) {
+  const resolved = options ?? {};
+  appInstance = resolved;
+  appLaunched = false;
+  if (!isRecord(appInstance.globalData)) {
+    appInstance.globalData = {};
+  }
+  return options;
+}
+function navigateTo(options) {
+  if (!options?.url) {
+    return Promise.resolve();
+  }
+  const { id, query } = parsePageUrl(options.url);
+  pushEntry(id, query);
+  return Promise.resolve();
+}
+function redirectTo(options) {
+  if (!options?.url) {
+    return Promise.resolve();
+  }
+  const { id, query } = parsePageUrl(options.url);
+  replaceEntry(id, query);
+  return Promise.resolve();
+}
+function reLaunch(options) {
+  if (!options?.url) {
+    return Promise.resolve();
+  }
+  const { id, query } = parsePageUrl(options.url);
+  relaunchEntry(id, query);
+  return Promise.resolve();
+}
+function switchTab(options) {
+  return redirectTo(options);
+}
+function navigateBack(options) {
+  if (navigationHistory.length <= 1) {
+    return Promise.resolve();
+  }
+  const delta = Math.max(1, options?.delta ?? 1);
+  const targetIndex = Math.max(0, navigationHistory.length - 1 - delta);
+  const target = navigationHistory[targetIndex];
+  navigationHistory.length = targetIndex;
+  pushEntry(target.id, target.query);
+  return Promise.resolve();
+}
+function getCurrentPagesInternal() {
+  return navigationHistory.map((entry) => entry.instance).filter((instance) => Boolean(instance));
+}
+function getAppInstance() {
+  return appInstance;
+}
+var globalTarget = typeof globalThis !== "undefined" ? globalThis : {};
+if (globalTarget) {
+  const wxBridge = globalTarget.wx ?? {};
+  Object.assign(wxBridge, {
+    navigateTo,
+    navigateBack,
+    redirectTo,
+    switchTab,
+    reLaunch
+  });
+  globalTarget.wx = wxBridge;
+  if (typeof globalTarget.getApp !== "function") {
+    globalTarget.getApp = getAppInstance;
+  }
+  if (typeof globalTarget.getCurrentPages !== "function") {
+    globalTarget.getCurrentPages = getCurrentPagesInternal;
+  }
+}
+
+// src/runtime/style.ts
+var injected = /* @__PURE__ */ new Map();
+function createStyleId(css) {
+  let hash = 2166136261;
+  for (let i = 0; i < css.length; i++) {
+    hash ^= css.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+  return `weapp-web-style-${(hash >>> 0).toString(36)}`;
+}
+function removeStyle(id) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const style = injected.get(id);
+  if (style) {
+    style.remove();
+    injected.delete(id);
+  }
+}
+function injectStyle(css, id) {
+  if (typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const styleId = id ?? createStyleId(css);
+  const existing = injected.get(styleId);
+  if (existing) {
+    existing.textContent = css;
+    return () => removeStyle(styleId);
+  }
+  const style = document.createElement("style");
+  style.id = styleId;
+  style.textContent = css;
+  document.head.append(style);
+  injected.set(styleId, style);
+  return () => removeStyle(styleId);
+}
+
+// src/runtime/template.ts
+import { parseDocument } from "htmlparser2";
+var CONTROL_ATTRS = /* @__PURE__ */ new Set([
+  "wx:if",
+  "wx:elif",
+  "wx:else",
+  "wx:for",
+  "wx:for-item",
+  "wx:for-index",
+  "wx:key"
+]);
+var EVENT_PREFIX_RE = /^(?:bind|catch|mut-bind|capture-bind|capture-catch)([\w-]+)$/;
+var EVENT_KIND_ALIAS = {
+  tap: "click"
+};
+var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "image",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var templateCache = /* @__PURE__ */ new Map();
+var expressionCache = /* @__PURE__ */ new Map();
+function filterRenderableNode(node) {
+  if (node.type === "directive" || node.type === "comment") {
+    return false;
+  }
+  if (node.type === "text") {
+    const data = node.data ?? "";
+    return data.trim().length > 0;
+  }
+  return true;
+}
+function getOrParseTemplate(source) {
+  let cached = templateCache.get(source);
+  if (!cached) {
+    const document2 = parseDocument(source, {
+      xmlMode: true,
+      decodeEntities: true,
+      recognizeSelfClosing: true
+    });
+    cached = (document2.children ?? []).filter(filterRenderableNode);
+    templateCache.set(source, cached);
+  }
+  return cached;
+}
+function createScope(initial) {
+  return Object.assign(/* @__PURE__ */ Object.create(null), initial ?? {});
+}
+function createChildScope(parent) {
+  return Object.assign(Object.create(parent), {});
+}
+function normalizeList(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value == null) {
+    return [];
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const length = Math.max(0, Math.floor(value));
+    return Array.from({ length }, (_, index) => index);
+  }
+  if (typeof value === "object") {
+    return Object.values(value);
+  }
+  return [];
+}
+function normalizeTagName(name) {
+  switch (name) {
+    case "view":
+    case "cover-view":
+    case "navigator":
+    case "scroll-view":
+    case "swiper":
+    case "swiper-item":
+    case "movable-area":
+    case "movable-view":
+    case "cover-image":
+      return "div";
+    case "text":
+    case "icon":
+      return "span";
+    case "image":
+      return "img";
+    case "button":
+      return "button";
+    case "input":
+      return "input";
+    case "textarea":
+      return "textarea";
+    case "form":
+      return "form";
+    case "label":
+      return "label";
+    case "picker":
+    case "picker-view":
+      return "select";
+    case "block":
+      return "#fragment";
+    default:
+      return name || "div";
+  }
+}
+function normalizeAttributeName(name) {
+  if (name === "class" || name === "style" || name.startsWith("data-")) {
+    return name;
+  }
+  if (name === "hover-class") {
+    return "data-hover-class";
+  }
+  return name.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (match) => {
+    switch (match) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      case "'":
+        return "&#39;";
+      default:
+        return match;
+    }
+  });
+}
+function escapeAttribute(value) {
+  return escapeHtml(value);
+}
+function toDisplayString(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+function unwrapExpression(expression) {
+  const trimmed = expression.trim();
+  if (trimmed.startsWith("{{") && trimmed.endsWith("}}")) {
+    return trimmed.slice(2, -2).trim();
+  }
+  return trimmed;
+}
+function evaluateExpression(expression, scope) {
+  if (!expression) {
+    return void 0;
+  }
+  const trimmed = unwrapExpression(expression);
+  if (!trimmed) {
+    return void 0;
+  }
+  let evaluator = expressionCache.get(trimmed);
+  if (!evaluator) {
+    try {
+      evaluator = new Function("scope", `with(scope){ return (${trimmed}); }`);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new SyntaxError(`[@weapp-vite/web] \u65E0\u6CD5\u89E3\u6790\u8868\u8FBE\u5F0F "${trimmed}": ${reason}`);
+    }
+    expressionCache.set(trimmed, evaluator);
+  }
+  try {
+    return evaluator(scope);
+  } catch {
+    return void 0;
+  }
+}
+function interpolateText(source, scope, escapeResult) {
+  if (!source.includes("{{")) {
+    return escapeResult ? escapeHtml(source) : source;
+  }
+  let cursor = 0;
+  let buffer = "";
+  while (cursor < source.length) {
+    const start = source.indexOf("{{", cursor);
+    if (start === -1) {
+      buffer += source.slice(cursor);
+      break;
+    }
+    buffer += source.slice(cursor, start);
+    const end = source.indexOf("}}", start + 2);
+    if (end === -1) {
+      buffer += source.slice(start);
+      break;
+    }
+    const expression = source.slice(start + 2, end).trim();
+    const evaluated = toDisplayString(evaluateExpression(expression, scope));
+    buffer += evaluated;
+    cursor = end + 2;
+  }
+  return escapeResult ? escapeHtml(buffer) : buffer;
+}
+function resolveAttributeValue(value, scope) {
+  return interpolateText(value ?? "", scope, false);
+}
+function extractFor(attribs) {
+  const expr = attribs["wx:for"];
+  const restAttribs = {};
+  const itemName = attribs["wx:for-item"]?.trim() || "item";
+  let indexName = attribs["wx:for-index"]?.trim() || "index";
+  for (const [key, val] of Object.entries(attribs)) {
+    if (key === "wx:for" || key === "wx:for-item" || key === "wx:for-index" || key === "wx:key") {
+      continue;
+    }
+    restAttribs[key] = val;
+  }
+  if (itemName === indexName) {
+    indexName = `${indexName}Index`;
+  }
+  return {
+    expr,
+    itemName,
+    indexName,
+    restAttribs
+  };
+}
+function buildAttributeString(attribs, scope) {
+  let result = "";
+  for (const [name, rawValue] of Object.entries(attribs)) {
+    if (CONTROL_ATTRS.has(name)) {
+      continue;
+    }
+    const eventMatch = EVENT_PREFIX_RE.exec(name);
+    if (eventMatch) {
+      const [, rawEvent] = eventMatch;
+      const event = rawEvent.toLowerCase();
+      const handlerName = resolveAttributeValue(rawValue, scope).trim();
+      if (!handlerName) {
+        continue;
+      }
+      const runtimeEvent = EVENT_KIND_ALIAS[event] ?? event;
+      result += ` data-wx-on-${runtimeEvent}="${escapeAttribute(handlerName)}"`;
+      continue;
+    }
+    const value = resolveAttributeValue(rawValue, scope);
+    if (value === "") {
+      continue;
+    }
+    const normalizedName = normalizeAttributeName(name);
+    result += ` ${normalizedName}="${escapeAttribute(value)}"`;
+  }
+  return result;
+}
+function stripControlAttributes(attribs) {
+  const result = {};
+  for (const [name, value] of Object.entries(attribs)) {
+    if (!CONTROL_ATTRS.has(name)) {
+      result[name] = value;
+    }
+  }
+  return result;
+}
+function isConditionalElement(node) {
+  if (node.type !== "tag") {
+    return false;
+  }
+  const attribs = node.attribs ?? {};
+  return "wx:if" in attribs || "wx:elif" in attribs || "wx:else" in attribs;
+}
+function renderConditionalSequence(nodes, startIndex, scope, renderChildren) {
+  const branches = [];
+  let cursor = startIndex;
+  while (cursor < nodes.length) {
+    const candidate = nodes[cursor];
+    if (!isConditionalElement(candidate)) {
+      break;
+    }
+    const element = candidate;
+    const attribs = element.attribs ?? {};
+    if (branches.length === 0 && !("wx:if" in attribs)) {
+      break;
+    }
+    if (branches.length > 0 && !("wx:elif" in attribs) && !("wx:else" in attribs)) {
+      break;
+    }
+    branches.push({ node: element, attribs });
+    cursor += 1;
+    if ("wx:else" in attribs) {
+      break;
+    }
+  }
+  if (!branches.length) {
+    const node = nodes[startIndex];
+    return {
+      rendered: renderChildren(node, scope),
+      endIndex: startIndex
+    };
+  }
+  for (const { node, attribs } of branches) {
+    if ("wx:else" in attribs) {
+      return {
+        rendered: renderElement(
+          node,
+          scope,
+          renderChildren,
+          { overrideAttribs: stripControlAttributes(attribs) }
+        ),
+        endIndex: startIndex + branches.length - 1
+      };
+    }
+    const conditionExpr = attribs["wx:if"] ?? attribs["wx:elif"];
+    if (!conditionExpr) {
+      continue;
+    }
+    const condition = evaluateExpression(conditionExpr, scope);
+    if (condition) {
+      return {
+        rendered: renderElement(
+          node,
+          scope,
+          renderChildren,
+          { overrideAttribs: stripControlAttributes(attribs) }
+        ),
+        endIndex: startIndex + branches.length - 1
+      };
+    }
+  }
+  return {
+    rendered: "",
+    endIndex: startIndex + branches.length - 1
+  };
+}
+function renderElement(node, scope, renderChildren, options = {}) {
+  const attribs = node.attribs ?? {};
+  if (!options.skipFor) {
+    const forExtract = extractFor(attribs);
+    if (forExtract.expr) {
+      const list = normalizeList(evaluateExpression(forExtract.expr, scope));
+      if (!list.length) {
+        return "";
+      }
+      let buffer = "";
+      for (let idx = 0; idx < list.length; idx++) {
+        const item = list[idx];
+        const childScope = createChildScope(scope);
+        childScope[forExtract.itemName] = item;
+        childScope[forExtract.indexName] = idx;
+        buffer += renderElement(node, childScope, renderChildren, {
+          skipFor: true,
+          overrideAttribs: forExtract.restAttribs
+        });
+      }
+      return buffer;
+    }
+  }
+  const effectiveAttribs = options.overrideAttribs ?? attribs;
+  const normalizedTag = normalizeTagName(node.name);
+  if (normalizedTag === "#fragment") {
+    return renderChildren(node.children, scope);
+  }
+  const attrs = buildAttributeString(effectiveAttribs, scope);
+  const children = renderChildren(node.children, scope);
+  if (SELF_CLOSING_TAGS.has(normalizedTag) && !children) {
+    return `<${normalizedTag}${attrs} />`;
+  }
+  return `<${normalizedTag}${attrs}>${children}</${normalizedTag}>`;
+}
+function renderTextNode(node, scope) {
+  const value = node.data ?? "";
+  if (!value.trim()) {
+    return "";
+  }
+  return interpolateText(value, scope, true);
+}
+function renderTree(input, scope) {
+  if (!input) {
+    return "";
+  }
+  if (Array.isArray(input)) {
+    let buffer = "";
+    for (let index = 0; index < input.length; index++) {
+      const node2 = input[index];
+      if (isConditionalElement(node2)) {
+        const { rendered, endIndex } = renderConditionalSequence(input, index, scope, renderTree);
+        buffer += rendered;
+        index = endIndex;
+        continue;
+      }
+      buffer += renderTree(node2, scope);
+    }
+    return buffer;
+  }
+  const node = input;
+  if (node.type === "text") {
+    return renderTextNode(node, scope);
+  }
+  if (node.type === "tag" || node.type === "script" || node.type === "style") {
+    return renderElement(node, scope, renderTree);
+  }
+  if ("children" in node && node.children?.length) {
+    return renderTree(node.children, scope);
+  }
+  return "";
+}
+function renderTemplate(nodes, scope) {
+  const renderScope = createScope(scope);
+  return renderTree(nodes, renderScope);
+}
+function createTemplate(source) {
+  const nodes = getOrParseTemplate(source);
+  return (scope) => renderTemplate(nodes, scope);
+}
+export {
+  createTemplate,
+  defineComponent,
+  initializePageRoutes,
+  injectStyle,
+  navigateBack,
+  navigateTo,
+  reLaunch,
+  redirectTo,
+  registerApp,
+  registerComponent,
+  registerPage,
+  removeStyle,
+  renderTemplate,
+  switchTab
+};