@yaoxiu/marketing-dsl 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1519 @@
+'use strict';
+
+// src/expression.ts
+var KEYWORD_LITERALS = {
+  true: true,
+  false: false,
+  null: null,
+  undefined: void 0
+};
+var PUNCTUATORS = [
+  "===",
+  "!==",
+  "<=",
+  ">=",
+  "==",
+  "!=",
+  "&&",
+  "||",
+  "(",
+  ")",
+  "[",
+  "]",
+  ".",
+  "?",
+  ":",
+  "<",
+  ">",
+  "!",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%"
+];
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let value = "";
+      i++;
+      while (i < input.length && input[i] !== quote) {
+        if (input[i] === "\\") {
+          value += input[i + 1] || "";
+          i += 2;
+        } else {
+          value += input[i];
+          i++;
+        }
+      }
+      if (i >= input.length) throw new Error("\u5B57\u7B26\u4E32\u6CA1\u6709\u95ED\u5408");
+      i++;
+      tokens.push({ type: "string", value });
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && /[0-9]/.test(input[i + 1] || "")) {
+      let raw = "";
+      while (i < input.length && /[0-9.]/.test(input[i])) {
+        raw += input[i];
+        i++;
+      }
+      tokens.push({ type: "number", value: Number(raw) });
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(ch)) {
+      let name = "";
+      while (i < input.length && /[A-Za-z0-9_$]/.test(input[i])) {
+        name += input[i];
+        i++;
+      }
+      tokens.push({ type: "ident", value: name });
+      continue;
+    }
+    const punctuator = PUNCTUATORS.find((p) => input.startsWith(p, i));
+    if (!punctuator) throw new Error(`\u65E0\u6CD5\u8BC6\u522B\u7684\u5B57\u7B26 "${ch}"`);
+    tokens.push({ type: "punc", value: punctuator });
+    i += punctuator.length;
+  }
+  return tokens;
+}
+function createParser(tokens) {
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const isPunc = (v) => {
+    const token = peek();
+    return !!token && token.type === "punc" && token.value === v;
+  };
+  const eat = (v) => {
+    if (!isPunc(v)) throw new Error(`\u7F3A\u5C11 "${v}"`);
+    pos++;
+  };
+  const binaryLevels = [
+    ["||"],
+    ["&&"],
+    ["===", "!==", "==", "!="],
+    ["<", ">", "<=", ">="],
+    ["+", "-"],
+    ["*", "/", "%"]
+  ];
+  function parseExpression() {
+    return parseTernary();
+  }
+  function parseTernary() {
+    const test = parseBinary(0);
+    if (!isPunc("?")) return test;
+    eat("?");
+    const consequent = parseTernary();
+    eat(":");
+    const alternate = parseTernary();
+    return { kind: "ternary", test, consequent, alternate };
+  }
+  function parseBinary(level) {
+    if (level >= binaryLevels.length) return parseUnary();
+    let left = parseBinary(level + 1);
+    for (; ; ) {
+      const token = peek();
+      if (!token || token.type !== "punc") break;
+      if (binaryLevels[level].indexOf(String(token.value)) === -1) break;
+      const operator = String(token.value);
+      pos++;
+      const right = parseBinary(level + 1);
+      left = { kind: "binary", operator, left, right };
+    }
+    return left;
+  }
+  function parseUnary() {
+    if (isPunc("!") || isPunc("-")) {
+      const operator = String(peek().value);
+      pos++;
+      return { kind: "unary", operator, argument: parseUnary() };
+    }
+    return parseMember();
+  }
+  function parseMember() {
+    let object = parsePrimary();
+    for (; ; ) {
+      if (isPunc(".")) {
+        eat(".");
+        const token = peek();
+        if (!token || token.type !== "ident") throw new Error('"." \u540E\u9762\u9700\u8981\u5C5E\u6027\u540D');
+        pos++;
+        object = {
+          kind: "member",
+          object,
+          property: { kind: "literal", value: token.value }
+        };
+      } else if (isPunc("[")) {
+        eat("[");
+        const property = parseExpression();
+        eat("]");
+        object = { kind: "member", object, property };
+      } else {
+        return object;
+      }
+    }
+  }
+  function parsePrimary() {
+    const token = peek();
+    if (!token) throw new Error("\u8868\u8FBE\u5F0F\u4E0D\u5B8C\u6574");
+    if (isPunc("(")) {
+      eat("(");
+      const node = parseExpression();
+      eat(")");
+      return node;
+    }
+    if (token.type === "number" || token.type === "string") {
+      pos++;
+      return { kind: "literal", value: token.value };
+    }
+    if (token.type === "ident") {
+      pos++;
+      const name = String(token.value);
+      if (Object.prototype.hasOwnProperty.call(KEYWORD_LITERALS, name)) {
+        return { kind: "literal", value: KEYWORD_LITERALS[name] };
+      }
+      return { kind: "identifier", name };
+    }
+    throw new Error(`\u610F\u5916\u7684\u7B26\u53F7 "${token.value}"`);
+  }
+  const ast = parseExpression();
+  if (pos < tokens.length) throw new Error(`\u8868\u8FBE\u5F0F\u7ED3\u5C3E\u6709\u591A\u4F59\u5185\u5BB9 "${tokens[pos].value}"`);
+  return ast;
+}
+var astCache = /* @__PURE__ */ new Map();
+function parse(source) {
+  const cached = astCache.get(source);
+  if (cached) return cached;
+  const ast = createParser(tokenize(source));
+  astCache.set(source, ast);
+  return ast;
+}
+var BLOCKED_KEYS = ["__proto__", "constructor", "prototype"];
+function readProperty(object, key) {
+  if (object === null || object === void 0) return void 0;
+  if (BLOCKED_KEYS.indexOf(String(key)) > -1) return void 0;
+  const value = object[String(key)];
+  return typeof value === "function" ? void 0 : value;
+}
+function evaluateNode(node, context) {
+  switch (node.kind) {
+    case "literal":
+      return node.value;
+    case "identifier":
+      return readProperty(context, node.name);
+    case "member":
+      return readProperty(
+        evaluateNode(node.object, context),
+        evaluateNode(node.property, context)
+      );
+    case "unary": {
+      const value = evaluateNode(node.argument, context);
+      return node.operator === "!" ? !value : -value;
+    }
+    case "ternary":
+      return evaluateNode(node.test, context) ? evaluateNode(node.consequent, context) : evaluateNode(node.alternate, context);
+    case "binary": {
+      if (node.operator === "&&") {
+        return evaluateNode(node.left, context) && evaluateNode(node.right, context);
+      }
+      if (node.operator === "||") {
+        return evaluateNode(node.left, context) || evaluateNode(node.right, context);
+      }
+      const left = evaluateNode(node.left, context);
+      const right = evaluateNode(node.right, context);
+      switch (node.operator) {
+        case "===":
+          return left === right;
+        case "!==":
+          return left !== right;
+        case "==":
+          return left == right;
+        case "!=":
+          return left != right;
+        case "<":
+          return left < right;
+        case ">":
+          return left > right;
+        case "<=":
+          return left <= right;
+        case ">=":
+          return left >= right;
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return left / right;
+        case "%":
+          return left % right;
+        default:
+          throw new Error(`\u4E0D\u652F\u6301\u7684\u8FD0\u7B97\u7B26 "${node.operator}"`);
+      }
+    }
+    default:
+      throw new Error("\u4E0D\u652F\u6301\u7684\u8282\u70B9\u7C7B\u578B");
+  }
+}
+function evaluate(source, context) {
+  try {
+    return evaluateNode(parse(source), context);
+  } catch (e) {
+    return void 0;
+  }
+}
+function check(source) {
+  try {
+    parse(source);
+    return "";
+  } catch (error) {
+    return error.message;
+  }
+}
+var INTERPOLATION_RE = /\{\{([\s\S]+?)\}\}/g;
+function interpolate(input, context) {
+  if (typeof input !== "string" || input.indexOf("{{") === -1) return input;
+  const trimmed = input.trim();
+  const tokens = trimmed.match(INTERPOLATION_RE) || [];
+  if (tokens.length === 1 && tokens[0] === trimmed) {
+    return evaluate(trimmed.slice(2, -2).trim(), context);
+  }
+  return input.replace(INTERPOLATION_RE, (_, expr) => {
+    const value = evaluate(expr.trim(), context);
+    return value === void 0 || value === null ? "" : String(value);
+  });
+}
+function interpolateDeep(input, context) {
+  if (typeof input === "string") return interpolate(input, context);
+  if (Array.isArray(input)) {
+    return input.map((item) => interpolateDeep(item, context));
+  }
+  if (input && typeof input === "object") {
+    const result = {};
+    Object.keys(input).forEach((key) => {
+      result[key] = interpolateDeep(input[key], context);
+    });
+    return result;
+  }
+  return input;
+}
+
+// src/url.ts
+var SAFE_PROTOCOLS = ["http:", "https:", "mailto:", "tel:"];
+function safeUrl(input) {
+  if (typeof input !== "string") return "";
+  const value = input.trim();
+  if (!value) return "";
+  if (/^(\/|\.{1,2}\/|#|\?)/.test(value)) return value;
+  const matched = value.match(/^([a-zA-Z][a-zA-Z0-9+.-]*:)/);
+  if (!matched) return value;
+  return SAFE_PROTOCOLS.indexOf(matched[1].toLowerCase()) > -1 ? value : "";
+}
+function safeImageUrl(input) {
+  if (typeof input === "string" && /^data:image\//i.test(input.trim())) {
+    return input.trim();
+  }
+  return safeUrl(input);
+}
+
+// src/actions.ts
+function createDispatcher(options) {
+  const { setState, emit, openView, closeTop, closeAll, handlers = {}, editMode = false } = options;
+  function dispatch(action, context) {
+    if (!action || !action.type) return;
+    switch (action.type) {
+      case "sequence":
+        (action.actions || []).forEach((item) => dispatch(item, context));
+        return;
+      case "navigate": {
+        const url = safeUrl(interpolate(action.url, context));
+        if (!url) {
+          emit("error", { type: "unsafe-url", raw: action.url });
+          return;
+        }
+        const target = action.target || "_blank";
+        emit("navigate", { url, target });
+        if (editMode) return;
+        if (typeof window === "undefined") return;
+        if (target === "_self") window.location.href = url;
+        else window.open(url, "_blank", "noopener,noreferrer");
+        return;
+      }
+      // 打开另一个视图：stack 叠一层（下面那层还在）、replace 换掉当前层
+      case "open":
+        emit("open", { view: action.view, mode: action.mode || "stack" });
+        openView(action.view, action.mode);
+        return;
+      // 关掉栈顶那层；只剩一层时就是整体关闭
+      case "close":
+        closeTop(action.reason);
+        return;
+      case "closeAll":
+        closeAll(action.reason);
+        return;
+      case "setState":
+        setState(action.key, interpolate(action.value, context));
+        return;
+      case "track":
+        emit("track", {
+          event: String(interpolate(action.event, context)),
+          params: interpolateDeep(action.params || {}, context)
+        });
+        return;
+      case "call": {
+        const handler = handlers[action.name];
+        if (typeof handler !== "function") {
+          emit("error", { type: "unknown-handler", name: action.name });
+          return;
+        }
+        const params = interpolateDeep(action.params || {}, context);
+        emit("call", { name: action.name, params });
+        if (editMode) return;
+        handler(params);
+        return;
+      }
+      default:
+        emit("error", {
+          type: "unknown-action",
+          action: action.type
+        });
+    }
+  }
+  return dispatch;
+}
+
+// src/countdown.ts
+function pad(value, len = 2) {
+  return String(value).padStart(len, "0");
+}
+function parseEndTime(to) {
+  if (typeof to === "number") return to;
+  if (to === void 0 || to === null || to === "") return 0;
+  const raw = String(to).trim();
+  if (/^\d+$/.test(raw)) return Number(raw);
+  const time = new Date(raw.replace(/-/g, "/")).getTime();
+  return isNaN(time) ? 0 : time;
+}
+function computeParts(endTime, now = Date.now()) {
+  const raw = endTime - now;
+  const remain = raw > 0 ? raw : 0;
+  const cs = Math.floor(remain / 10);
+  const sec = Math.floor(cs / 100);
+  return {
+    d: String(Math.floor(sec / 86400)),
+    // h 是 0~23；跨天还想连着数小时的用 hAll（如 143:58:07）
+    h: pad(Math.floor(sec % 86400 / 3600)),
+    hAll: pad(Math.floor(sec / 3600)),
+    m: pad(Math.floor(sec % 3600 / 60)),
+    s: pad(sec % 60),
+    cs: pad(cs % 100),
+    ended: !endTime || remain <= 0
+  };
+}
+function formatParts(parts, format) {
+  return (format || "{d}\u5929 {h}:{m}:{s}").replace("{d}", parts.d).replace("{hAll}", parts.hAll).replace("{h}", parts.h).replace("{m}", parts.m).replace("{s}", parts.s).replace("{cs}", parts.cs);
+}
+function createTicker(options) {
+  let timer = null;
+  let raf = 0;
+  let running = false;
+  let precision = "s";
+  let endTimes = [];
+  const hasRaf = typeof requestAnimationFrame === "function";
+  function allEnded() {
+    const now = Date.now();
+    return endTimes.every((end) => !end || end - now <= 0);
+  }
+  function tick() {
+    options.onTick();
+    if (allEnded()) {
+      stop();
+      if (options.onAllEnded) options.onAllEnded();
+    }
+  }
+  function stop() {
+    running = false;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    if (raf) {
+      cancelAnimationFrame(raf);
+      raf = 0;
+    }
+  }
+  function sync(nextEndTimes, nextPrecision) {
+    const changed = nextPrecision !== precision || nextEndTimes.length !== endTimes.length || nextEndTimes.some((end, i) => end !== endTimes[i]);
+    endTimes = nextEndTimes;
+    precision = nextPrecision;
+    if (!changed && running) return;
+    stop();
+    if (!endTimes.length || allEnded()) return;
+    running = true;
+    if (precision === "cs" && hasRaf) {
+      const loop = () => {
+        tick();
+        if (running) raf = requestAnimationFrame(loop);
+      };
+      raf = requestAnimationFrame(loop);
+    } else {
+      timer = setInterval(tick, 1e3);
+    }
+  }
+  return { sync, stop };
+}
+
+// src/views.ts
+var SINGLE_VIEW_NAME = "main";
+function normalizeViews(dsl) {
+  if (!dsl || typeof dsl !== "object") {
+    return { entry: SINGLE_VIEW_NAME, views: {}, isMulti: false };
+  }
+  if (dsl.views && typeof dsl.views === "object" && !Array.isArray(dsl.views)) {
+    const names = Object.keys(dsl.views);
+    return {
+      entry: dsl.entry && dsl.views[dsl.entry] ? dsl.entry : names[0],
+      views: dsl.views,
+      isMulti: true
+    };
+  }
+  return {
+    entry: SINGLE_VIEW_NAME,
+    views: {
+      [SINGLE_VIEW_NAME]: {
+        type: dsl.type,
+        stage: dsl.stage,
+        nodes: dsl.nodes
+      }
+    },
+    isMulti: false
+  };
+}
+
+// src/style.ts
+function toLength(value) {
+  return typeof value === "number" ? `${value}px` : String(value);
+}
+var px = toLength;
+var LENGTH_RE = /^-?(\d+(\.\d+)?)(px|%|em|rem|vw|vh)$/;
+function isLength(value) {
+  if (typeof value === "number") return isFinite(value);
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (trimmed === "auto" || trimmed === "0") return true;
+  if (/^calc\([^;{}]*\)$/.test(trimmed)) return true;
+  return LENGTH_RE.test(trimmed);
+}
+var STYLE_MAP = {
+  // 文字
+  color: ["color", String],
+  fontSize: ["fontSize", px],
+  fontWeight: ["fontWeight", String],
+  fontFamily: ["fontFamily", String],
+  lineHeight: ["lineHeight", (v) => typeof v === "number" && v > 4 ? px(v) : String(v)],
+  letterSpacing: ["letterSpacing", px],
+  textAlign: ["textAlign", String],
+  textDecoration: ["textDecoration", String],
+  whiteSpace: ["whiteSpace", String],
+  // 倒计时这类逐帧变化的数字必须等宽，否则数字会左右抖动
+  fontVariantNumeric: ["fontVariantNumeric", String],
+  // 背景
+  background: ["background", String],
+  backgroundImage: ["backgroundImage", (v) => `url(${JSON.stringify(String(v))})`],
+  backgroundSize: ["backgroundSize", String],
+  backgroundPosition: ["backgroundPosition", String],
+  backgroundRepeat: ["backgroundRepeat", String],
+  // 边框与圆角
+  border: ["border", String],
+  borderColor: ["borderColor", String],
+  borderWidth: ["borderWidth", px],
+  borderStyle: ["borderStyle", String],
+  radius: ["borderRadius", px],
+  // 盒模型
+  padding: ["padding", px],
+  margin: ["margin", px],
+  marginTop: ["marginTop", px],
+  marginBottom: ["marginBottom", px],
+  marginLeft: ["marginLeft", px],
+  marginRight: ["marginRight", px],
+  overflow: ["overflow", String],
+  opacity: ["opacity", String],
+  shadow: ["boxShadow", String],
+  cursor: ["cursor", String],
+  // flex 容器
+  direction: ["flexDirection", (v) => v === "column" ? "column" : "row"],
+  gap: ["gap", px],
+  wrap: ["flexWrap", (v) => v ? "wrap" : "nowrap"],
+  align: ["alignItems", String],
+  justify: ["justifyContent", String],
+  // flex 子项
+  flex: ["flex", String],
+  // 不写时子项会被拉满父级交叉轴，标签这类「按内容宽度」的元素要显式声明
+  alignSelf: ["alignSelf", String],
+  width: ["width", px],
+  height: ["height", px],
+  minWidth: ["minWidth", px],
+  minHeight: ["minHeight", px],
+  maxWidth: ["maxWidth", px],
+  maxHeight: ["maxHeight", px],
+  // 图片
+  objectFit: ["objectFit", String],
+  // 宽度给百分比、高度按比例算。整图 banner 的热区必须靠它才能用百分比定位：
+  // 容器没有真实高度时，子节点的百分比 rect 算出来全是 0。
+  aspectRatio: ["aspectRatio", String]
+};
+var ALLOWED_STYLE_KEYS = Object.keys(STYLE_MAP);
+function toCssStyle(style) {
+  const css = {};
+  if (!style) return css;
+  Object.keys(style).forEach((key) => {
+    const rule = STYLE_MAP[key];
+    if (!rule) return;
+    const value = style[key];
+    if (value === void 0 || value === null || value === "") return;
+    css[rule[0]] = rule[1](value);
+  });
+  return css;
+}
+function toRectStyle(rect) {
+  if (!Array.isArray(rect)) return {};
+  const [x, y, w, h] = rect;
+  const css = { position: "absolute", left: px(x || 0), top: px(y || 0) };
+  if (w !== void 0 && w !== null && w !== "auto") css.width = px(w);
+  if (h !== void 0 && h !== null && h !== "auto") css.height = px(h);
+  return css;
+}
+function resolveNodeStyle(node, layout) {
+  return Object.assign(
+    {},
+    layout === "absolute" ? toRectStyle(node.rect) : {},
+    toCssStyle(node.style)
+  );
+}
+
+// src/resolve.ts
+function resolveTree(input) {
+  const { normalized, viewStack, ready } = input;
+  const layers = viewStack.map((name) => ({ name, view: normalized.views[name] })).filter((item) => !!item.view);
+  const hasPopup = Object.keys(normalized.views).some(
+    (name) => normalized.views[name].type === "popup"
+  );
+  const countdowns = { endTimes: [], precision: "s" };
+  const renderLayers = ready ? layers.map(
+    (item, index) => resolveLayer(item.name, item.view, index === layers.length - 1, input, countdowns)
+  ) : [];
+  return {
+    ready: ready && layers.length > 0,
+    hasPopup,
+    // 配置里有弹窗视图时，根容器要撑满宿主容器，弹窗层才有地方铺
+    rootStyle: hasPopup ? { position: "absolute", top: "0", right: "0", bottom: "0", left: "0" } : { position: "relative" },
+    layers: renderLayers,
+    countdownEndTimes: countdowns.endTimes,
+    countdownPrecision: countdowns.precision
+  };
+}
+function resolveLayer(name, view, isTop, input, countdowns) {
+  const { context, closeTop } = input;
+  const stage = view.stage || {};
+  const isPopup = view.type === "popup";
+  const rootLayout = stage.layout === "flow" ? "flow" : "absolute";
+  const maskClosable = !!stage.maskClosable;
+  const onMaskClick = maskClosable ? () => closeTop("mask") : void 0;
+  const nodes = (view.nodes || []).map((node, index) => resolveNode(node, `${name}-${index}`, rootLayout, context, input, countdowns)).filter((el) => !!el);
+  return {
+    name,
+    type: view.type,
+    isTop,
+    // 只有栈顶那层画遮罩，否则两层遮罩叠加会明显变黑
+    mask: isPopup && stage.mask !== false && isTop,
+    onMaskClick,
+    layerStyle: layerStyle(isPopup, isTop),
+    maskStyle: {
+      position: "absolute",
+      top: "0",
+      right: "0",
+      bottom: "0",
+      left: "0",
+      background: "rgba(0, 0, 0, 0.55)"
+    },
+    scrollStyle: scrollStyle(isPopup),
+    stageStyle: resolveStageStyle(stage, isPopup, context),
+    clipStyle: {
+      position: "relative",
+      height: "100%",
+      borderRadius: "inherit",
+      overflow: "hidden",
+      boxSizing: "border-box"
+    },
+    closeButton: resolveCloseButton(stage.closeButton, name, closeTop),
+    nodes
+  };
+}
+function layerStyle(isPopup, isTop) {
+  const style = isPopup ? { position: "absolute", top: "0", right: "0", bottom: "0", left: "0" } : {};
+  if (!isTop) style.pointerEvents = "none";
+  return style;
+}
+function scrollStyle(isPopup) {
+  if (!isPopup) return {};
+  return {
+    position: "absolute",
+    top: "0",
+    right: "0",
+    bottom: "0",
+    left: "0",
+    display: "flex",
+    overflow: "auto",
+    padding: "20px",
+    boxSizing: "border-box"
+  };
+}
+function resolveStageStyle(stage, isPopup, context) {
+  const base = {
+    position: "relative",
+    boxSizing: "border-box",
+    background: "#fff"
+  };
+  if (isPopup) {
+    base.margin = "auto";
+    base.flex = "none";
+  }
+  return Object.assign(
+    base,
+    {
+      // width / height 支持数字（px）、'100%' / 'auto' / calc(...) 等相对单位，也支持 {{ }}
+      width: toLength(interpolate(stage.width === void 0 ? 320 : stage.width, context)),
+      height: toLength(interpolate(stage.height === void 0 ? 400 : stage.height, context))
+    },
+    // stage.style 也走一遍插值，这样切 tab 时弹窗本身的背景能跟着变
+    toCssStyle(interpolateDeep(stage.style, context))
+  );
+}
+function resolveCloseButton(config, layerName, closeTop) {
+  if (!config || config.show === false) return void 0;
+  const offset = config.offset || [8, 8];
+  const size = config.size === void 0 ? 26 : config.size;
+  const position = config.position || "top-right";
+  const style = {
+    position: "absolute",
+    width: toLength(size),
+    height: toLength(size),
+    lineHeight: toLength(size),
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    boxSizing: "border-box",
+    borderRadius: "50%",
+    background: "rgba(0, 0, 0, 0.35)",
+    color: "#fff",
+    fontSize: "18px",
+    textAlign: "center",
+    cursor: "pointer",
+    userSelect: "none",
+    zIndex: "1"
+  };
+  if (position.indexOf("bottom") === 0) style.bottom = toLength(offset[1]);
+  else style.top = toLength(offset[1]);
+  if (position.indexOf("center") > -1) {
+    style.left = "50%";
+    style.transform = "translateX(-50%)";
+  } else if (position.indexOf("left") > -1) {
+    style.left = toLength(offset[0]);
+  } else {
+    style.right = toLength(offset[0]);
+  }
+  Object.assign(style, toCssStyle(config.style));
+  const onClick = () => closeTop("close-button");
+  const image = config.image ? safeImageUrl(config.image) : "";
+  if (image) {
+    return {
+      key: `${layerName}-close`,
+      tag: "div",
+      style,
+      onClick,
+      children: [
+        {
+          key: `${layerName}-close-img`,
+          tag: "img",
+          src: image,
+          style: { width: "100%", height: "100%", objectFit: "contain", display: "block" }
+        }
+      ]
+    };
+  }
+  return {
+    key: `${layerName}-close`,
+    tag: "div",
+    style,
+    onClick,
+    text: config.icon || "\xD7"
+  };
+}
+var BASE_STYLE = { boxSizing: "border-box" };
+function resolveNode(node, key, layout, context, input, countdowns) {
+  if (!node || typeof node !== "object") return void 0;
+  if (node.visibleWhen && !evaluate(node.visibleWhen, context)) return void 0;
+  const style = Object.assign(
+    {},
+    BASE_STYLE,
+    resolveNodeStyle(
+      { rect: node.rect, style: interpolateDeep(node.style, context) },
+      layout
+    )
+  );
+  const onClick = node.action ? () => input.dispatch(node.action, context) : void 0;
+  if (onClick && !style.cursor) style.cursor = "pointer";
+  switch (node.type) {
+    case "box":
+      return {
+        key,
+        tag: "div",
+        style: Object.assign({ position: "relative" }, style),
+        onClick,
+        children: resolveChildren(node.children, key, "absolute", context, input, countdowns)
+      };
+    case "flex":
+      return {
+        key,
+        tag: "div",
+        style: Object.assign({ display: "flex" }, style),
+        onClick,
+        children: resolveChildren(node.children, key, "flow", context, input, countdowns)
+      };
+    case "repeat":
+      return {
+        key,
+        tag: "div",
+        style: Object.assign({ display: "flex" }, style),
+        onClick,
+        children: resolveRepeat(node, key, context, input, countdowns)
+      };
+    case "tabs":
+      return {
+        key,
+        tag: "div",
+        style: Object.assign({ display: "flex" }, style),
+        children: resolveTabs(node, key, context, input)
+      };
+    case "image":
+      return {
+        key,
+        tag: "img",
+        src: safeImageUrl(interpolate(node.src, context)),
+        style: Object.assign({ display: "block", objectFit: "cover" }, style),
+        onClick
+      };
+    case "text":
+      return {
+        key,
+        tag: "div",
+        style: Object.assign({ wordBreak: "break-word" }, style),
+        text: toText(interpolate(node.content, context)),
+        onClick
+      };
+    case "button":
+      return {
+        key,
+        tag: "div",
+        style: Object.assign(
+          {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            textAlign: "center",
+            cursor: "pointer",
+            userSelect: "none"
+          },
+          style
+        ),
+        text: toText(interpolate(node.text, context)),
+        onClick
+      };
+    case "countdown":
+      return resolveCountdown(node, key, style, context, input, countdowns);
+    // 配置比解释器新时，未知类型降级为不渲染，不阻断整个弹窗
+    default:
+      return void 0;
+  }
+}
+function resolveChildren(children, parentKey, layout, context, input, countdowns) {
+  return (children || []).map(
+    (child, index) => resolveNode(child, `${parentKey}-${index}`, layout, context, input, countdowns)
+  ).filter((el) => !!el);
+}
+function resolveRepeat(node, key, context, input, countdowns) {
+  const list = evaluate(node.bind || "", context);
+  if (!Array.isArray(list) || !node.template) return [];
+  return list.map((item, index) => {
+    const itemContext = Object.assign({}, context, {
+      [node.itemName || "item"]: item,
+      [node.indexName || "index"]: index
+    });
+    return resolveNode(node.template, `${key}-${index}`, "flow", itemContext, input, countdowns);
+  }).filter((el) => !!el);
+}
+function resolveTabs(node, key, context, input) {
+  const list = evaluate(node.bind || "", context);
+  if (!Array.isArray(list)) return [];
+  const stateKey = node.stateKey || "";
+  const active = Number(input.state[stateKey]) || 0;
+  const labelField = node.labelField || "label";
+  return list.map((item, index) => {
+    const base = node.itemStyle || {};
+    const merged = index === active ? Object.assign({}, base, node.activeItemStyle || {}) : base;
+    const label = item && typeof item === "object" ? item[labelField] : item;
+    return {
+      key: `${key}-${index}`,
+      tag: "div",
+      style: Object.assign(
+        {
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          cursor: "pointer",
+          userSelect: "none"
+        },
+        BASE_STYLE,
+        toCssStyle(interpolateDeep(merged, context))
+      ),
+      text: label === void 0 || label === null ? `\u9009\u9879${index + 1}` : String(label),
+      onClick: () => {
+        input.setState(stateKey, index);
+        if (node.action) input.dispatch(node.action, context);
+      }
+    };
+  });
+}
+function resolveCountdown(node, key, style, context, input, countdowns) {
+  var _a;
+  const endTime = parseEndTime(interpolate(node.to, context));
+  const parts = computeParts(endTime);
+  countdowns.endTimes.push(endTime);
+  if (node.precision === "cs") countdowns.precision = "cs";
+  if (parts.ended && endTime && node.onEnd) {
+    const token = `${key}@${endTime}`;
+    if (!input.firedEnds.has(token)) {
+      input.firedEnds.add(token);
+      input.dispatch(node.onEnd, context);
+    }
+  }
+  if (parts.ended && !((_a = node.children) == null ? void 0 : _a.length)) {
+    return {
+      key,
+      tag: "div",
+      style: Object.assign({ wordBreak: "break-word" }, style),
+      text: node.endText || "\u5DF2\u7ED3\u675F"
+    };
+  }
+  if (!node.children || !node.children.length) {
+    return {
+      key,
+      tag: "div",
+      style: Object.assign({ wordBreak: "break-word" }, style),
+      text: formatParts(parts, node.format)
+    };
+  }
+  const childContext = Object.assign({}, context, { [node.as || "cd"]: parts });
+  return {
+    key,
+    tag: "div",
+    style: Object.assign({ display: "flex" }, style),
+    children: resolveChildren(node.children, key, "flow", childContext, input, countdowns)
+  };
+}
+function toText(value) {
+  return value === void 0 || value === null ? "" : String(value);
+}
+
+// src/runtime.ts
+var noopEmit = () => {
+};
+function createRuntime(dsl, options = {}) {
+  const { user = {}, sources = {}, handlers = {}, editMode = false, emit = noopEmit } = options;
+  const normalized = normalizeViews(dsl);
+  let state = Object.assign({}, dsl.state || {});
+  let resolvedData = {};
+  let viewStack = [normalized.entry];
+  let loading = true;
+  let loadFailed = false;
+  let destroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const firedEnds = /* @__PURE__ */ new Set();
+  const notify = () => {
+    if (destroyed) return;
+    listeners.forEach((fn) => fn());
+  };
+  const ticker = createTicker({ onTick: notify });
+  function buildContext() {
+    const context = Object.assign({}, resolvedData, { state, user });
+    const derived = dsl.derived || {};
+    Object.keys(derived).forEach((name) => {
+      const config = derived[name] || {};
+      const list = resolvedData[config.list];
+      const index = Number(state[config.indexBy]) || 0;
+      context[name] = Array.isArray(list) ? list[index] : void 0;
+    });
+    return context;
+  }
+  function setState(key, value) {
+    state = Object.assign({}, state, { [key]: value });
+    emit("state-change", Object.assign({}, state));
+    notify();
+  }
+  function openView(name, mode) {
+    if (!normalized.views[name]) {
+      emit("error", { type: "unknown-view", name });
+      return;
+    }
+    if (mode === "replace") {
+      const replaced = viewStack[viewStack.length - 1];
+      fireLifecycle(replaced, "onClose", { closeReason: "replace" });
+      viewStack = viewStack.slice(0, -1).concat(name);
+    } else {
+      viewStack = viewStack.concat(name);
+    }
+    emit("view-change", { view: name, mode: mode || "stack", stack: viewStack.slice() });
+    notify();
+    fireLifecycle(name, "onShow");
+  }
+  function closeTop(reason) {
+    const why = reason || "action";
+    if (viewStack.length > 1) {
+      const closed = viewStack[viewStack.length - 1];
+      viewStack = viewStack.slice(0, -1);
+      fireLifecycle(closed, "onClose", { closeReason: why });
+      emit("view-change", {
+        view: viewStack[viewStack.length - 1],
+        mode: "close",
+        stack: viewStack.slice(),
+        closed
+      });
+      notify();
+      return;
+    }
+    fireLifecycle(viewStack[0], "onClose", { closeReason: why });
+    emit("close", { reason: why });
+  }
+  function closeAll(reason) {
+    const why = reason || "action";
+    viewStack.slice().reverse().forEach((name) => fireLifecycle(name, "onClose", { closeReason: why }));
+    emit("close", { reason: why });
+  }
+  const dispatch = createDispatcher({
+    setState,
+    emit,
+    openView,
+    // 配置里 close 可以自带 reason（如 'never-remind'），要透传给埋点，不能吞掉
+    closeTop: (reason) => closeTop(reason),
+    closeAll: (reason) => closeAll(reason),
+    handlers,
+    editMode
+  });
+  function fireLifecycle(viewName, hook, extra) {
+    const view = normalized.views[viewName];
+    const action = view && view.stage && view.stage[hook];
+    if (!action) return;
+    dispatch(action, Object.assign({}, buildContext(), extra));
+  }
+  function loadData() {
+    const data = dsl.data || {};
+    const resolved = {};
+    const pending = [];
+    Object.keys(data).forEach((key) => {
+      const value = data[key];
+      const isSource = !!value && typeof value === "object" && !Array.isArray(value) && "$source" in value;
+      if (!isSource) {
+        resolved[key] = value;
+        return;
+      }
+      const ref = value;
+      const source = sources[ref.$source];
+      if (typeof source !== "function") {
+        emit("error", { type: "unknown-source", name: ref.$source });
+        pending.push(Promise.reject(new Error(`\u672A\u6CE8\u518C\u7684\u6570\u636E\u6E90 ${ref.$source}`)));
+        return;
+      }
+      pending.push(
+        Promise.resolve(source(ref.params || {}, user)).then((result) => {
+          resolved[key] = result;
+        })
+      );
+    });
+    Promise.all(pending).then(() => {
+      if (destroyed) return;
+      resolvedData = resolved;
+      loading = false;
+      notify();
+      emit("ready", { keys: Object.keys(resolved) });
+      fireLifecycle(normalized.entry, "onShow");
+    }).catch((error) => {
+      if (destroyed) return;
+      loading = false;
+      loadFailed = true;
+      notify();
+      emit("error", { type: "data-source-failed", message: error.message });
+    });
+  }
+  loadData();
+  function getTree() {
+    const tree = resolveTree({
+      normalized,
+      viewStack,
+      context: buildContext(),
+      state,
+      ready: !loading && !loadFailed,
+      dispatch,
+      setState,
+      closeTop,
+      firedEnds
+    });
+    ticker.sync(tree.countdownEndTimes, tree.countdownPrecision);
+    return tree;
+  }
+  return {
+    getTree,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getState: () => Object.assign({}, state),
+    getViewStack: () => viewStack.slice(),
+    destroy() {
+      destroyed = true;
+      ticker.stop();
+      listeners.clear();
+    }
+  };
+}
+
+// src/validate.ts
+var LENGTH_STYLE_KEYS = [
+  "width",
+  "height",
+  "minWidth",
+  "minHeight",
+  "maxWidth",
+  "maxHeight",
+  "radius",
+  "padding",
+  "margin",
+  "marginTop",
+  "marginBottom",
+  "marginLeft",
+  "marginRight",
+  "gap",
+  "fontSize",
+  "letterSpacing",
+  "borderWidth"
+];
+var DSL_VERSION = 1;
+var NODE_TYPES = [
+  "box",
+  "flex",
+  "repeat",
+  "image",
+  "text",
+  "button",
+  "tabs",
+  "countdown"
+];
+var ACTION_TYPES = [
+  "navigate",
+  "close",
+  "closeAll",
+  "open",
+  "setState",
+  "track",
+  "call",
+  "sequence"
+];
+var CLOSE_POSITIONS = [
+  "top-right",
+  "top-left",
+  "top-center",
+  "bottom-right",
+  "bottom-left",
+  "bottom-center"
+];
+var CONTAINER_TYPES = ["box", "flex"];
+function validate(dsl) {
+  const errors = [];
+  const warnings = [];
+  const add = (path, message) => errors.push({ path, message });
+  const warn = (path, message) => warnings.push({ path, message });
+  if (!dsl || typeof dsl !== "object" || Array.isArray(dsl)) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: "\u6839\u8282\u70B9\u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61" }],
+      warnings
+    };
+  }
+  const doc = dsl;
+  if (doc.version !== DSL_VERSION) {
+    add("version", `version \u5FC5\u987B\u662F ${DSL_VERSION}\uFF0C\u5F53\u524D\u4E3A ${JSON.stringify(doc.version)}`);
+  }
+  const dataKeys = validateData(doc.data, add);
+  const stateKeys = validateState(doc.state, add);
+  validateDerived(doc.derived, dataKeys, stateKeys, add);
+  const isMulti = doc.views !== void 0;
+  if (isMulti) validateMultiView(doc, add);
+  const { views } = normalizeViews(doc);
+  const viewNames = Object.keys(views);
+  const ctx = { add, warn, viewNames };
+  viewNames.forEach((name) => {
+    validateView(views[name], isMulti ? `views.${name}` : "", ctx);
+  });
+  return { valid: errors.length === 0, errors, warnings };
+}
+function validateMultiView(dsl, add) {
+  if (typeof dsl.views !== "object" || dsl.views === null || Array.isArray(dsl.views)) {
+    add("views", 'views \u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u5F62\u5982 { "main": { type, stage, nodes } }');
+    return;
+  }
+  if (!Object.keys(dsl.views).length) {
+    add("views", "views \u81F3\u5C11\u8981\u6709\u4E00\u4E2A\u89C6\u56FE");
+    return;
+  }
+  if (dsl.entry === void 0) {
+    add("entry", "\u591A\u89C6\u56FE\u5FC5\u987B\u6307\u5B9A entry\uFF08\u9996\u4E2A\u5C55\u793A\u7684\u89C6\u56FE\u540D\uFF09");
+  } else if (!dsl.views[dsl.entry]) {
+    add("entry", `entry "${dsl.entry}" \u5728 views \u91CC\u4E0D\u5B58\u5728`);
+  }
+  ["stage", "nodes"].forEach((key) => {
+    if (dsl[key] !== void 0) {
+      add(key, `\u7528\u4E86 views \u4E4B\u540E\uFF0C${key} \u8981\u5199\u5728\u6BCF\u4E2A\u89C6\u56FE\u91CC\uFF0C\u4E0D\u80FD\u7559\u5728\u9876\u5C42`);
+    }
+  });
+}
+function validateView(view, prefix, ctx) {
+  const { add, warn } = ctx;
+  const at = (key) => prefix ? `${prefix}.${key}` : key;
+  if (!view || typeof view !== "object" || Array.isArray(view)) {
+    add(prefix || "view", "\u89C6\u56FE\u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u5305\u542B type / stage / nodes");
+    return;
+  }
+  if (["popup", "banner", "notice"].indexOf(view.type) === -1) {
+    add(at("type"), "type \u5FC5\u987B\u662F popup / banner / notice \u4E4B\u4E00");
+  }
+  validateStage(
+    view.stage,
+    (path, message) => add(prefix ? `${prefix}.${path}` : path, message),
+    warn,
+    ctx,
+    prefix
+  );
+  if (!Array.isArray(view.nodes) || view.nodes.length === 0) {
+    add(at("nodes"), "nodes \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+    return;
+  }
+  const rootLayout = (view.stage || {}).layout === "flow" ? "flow" : "absolute";
+  view.nodes.forEach((node, index) => {
+    validateNode(node, at(`nodes[${index}]`), rootLayout, ctx);
+  });
+}
+function checkLength(value) {
+  if (typeof value === "string" && value.indexOf("{{") > -1) return true;
+  if (typeof value === "number") return isLength(value);
+  if (typeof value !== "string") return false;
+  if (isLength(value)) return true;
+  return value.trim().split(/\s+/).every(isLength);
+}
+function checkAspectRatio(value) {
+  if (typeof value === "string" && value.indexOf("{{") > -1) return true;
+  if (typeof value === "number") return isFinite(value) && value > 0;
+  if (typeof value !== "string") return false;
+  return /^\s*\d+(\.\d+)?\s*(\/\s*\d+(\.\d+)?\s*)?$/.test(value);
+}
+function validateStage(stage, add, warn, ctx, prefix) {
+  if (stage === void 0) {
+    add("stage", "\u7F3A\u5C11 stage");
+    return;
+  }
+  if (typeof stage !== "object" || stage === null) {
+    add("stage", "stage \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (!checkLength(stage.width)) {
+    add(
+      "stage.width",
+      "stage.width \u5FC5\u987B\u662F\u6570\u5B57(px)\u6216\u957F\u5EA6\u5B57\u7B26\u4E32\uFF0C\u5982 460 / '100%' / 'calc(100% - 32px)'"
+    );
+  }
+  if (!checkLength(stage.height)) {
+    add("stage.height", "stage.height \u5FC5\u987B\u662F\u6570\u5B57(px)\u6216\u957F\u5EA6\u5B57\u7B26\u4E32\uFF0C\u5982 520 / 'auto'");
+  }
+  if (stage.layout !== void 0 && ["absolute", "flow"].indexOf(stage.layout) === -1) {
+    add("stage.layout", "stage.layout \u53EA\u80FD\u662F 'absolute'\uFF08\u9ED8\u8BA4\uFF09\u6216 'flow'");
+  }
+  validateCloseButton(stage.closeButton, add, warn);
+  const at = (key) => prefix ? `${prefix}.stage.${key}` : `stage.${key}`;
+  if (stage.onShow !== void 0) validateAction(stage.onShow, at("onShow"), ctx);
+  if (stage.onClose !== void 0) validateAction(stage.onClose, at("onClose"), ctx);
+  if (stage.height === "auto" && stage.layout !== "flow") {
+    add("stage.height", "height: 'auto' \u9700\u8981\u540C\u65F6\u8BBE\u7F6E stage.layout: 'flow'\uFF0C\u5426\u5219\u9AD8\u5EA6\u4F1A\u584C\u6210 0");
+  }
+}
+function validateCloseButton(config, add, warn) {
+  if (config === void 0) return;
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    add("stage.closeButton", "closeButton \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (config.position !== void 0 && CLOSE_POSITIONS.indexOf(config.position) === -1) {
+    add("stage.closeButton.position", `position \u53EA\u80FD\u662F ${CLOSE_POSITIONS.join(" / ")}`);
+  }
+  if (config.offset !== void 0) {
+    if (!Array.isArray(config.offset) || config.offset.length !== 2) {
+      add("stage.closeButton.offset", "offset \u5FC5\u987B\u662F [x, y] \u4E24\u9879\u6570\u7EC4\uFF0C\u8D1F\u503C\u4F1A\u628A\u6309\u94AE\u79FB\u5230\u5F39\u7A97\u5916\u9762");
+    } else {
+      config.offset.forEach((value, index) => {
+        if (!checkLength(value)) {
+          add(`stage.closeButton.offset[${index}]`, `"${value}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6`);
+        }
+      });
+    }
+  }
+  if (config.size !== void 0 && !checkLength(config.size)) {
+    add("stage.closeButton.size", `"${config.size}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6`);
+  }
+  if (config.icon !== void 0 && typeof config.icon !== "string") {
+    add("stage.closeButton.icon", "icon \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  if (config.image !== void 0 && typeof config.image !== "string") {
+    add("stage.closeButton.image", "image \u5FC5\u987B\u662F\u56FE\u7247\u94FE\u63A5\u5B57\u7B26\u4E32");
+  }
+  if (config.style) {
+    Object.keys(config.style).forEach((key) => {
+      if (ALLOWED_STYLE_KEYS.indexOf(key) === -1) {
+        warn(`stage.closeButton.style.${key}`, `\u6837\u5F0F\u5C5E\u6027 "${key}" \u4E0D\u5728\u767D\u540D\u5355\u5185\uFF0C\u6E32\u67D3\u65F6\u4F1A\u88AB\u5FFD\u7565`);
+      }
+    });
+  }
+}
+function validateData(data, add) {
+  if (data === void 0) return [];
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    add("data", "data \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return [];
+  }
+  Object.keys(data).forEach((key) => {
+    const value = data[key];
+    if (value && typeof value === "object" && !Array.isArray(value) && value.$source) {
+      if (typeof value.$source !== "string") {
+        add(`data.${key}.$source`, "$source \u5FC5\u987B\u662F\u6570\u636E\u6E90\u540D\u79F0\u5B57\u7B26\u4E32");
+      }
+      if (value.params !== void 0 && (typeof value.params !== "object" || value.params === null)) {
+        add(`data.${key}.params`, "params \u5FC5\u987B\u662F\u5BF9\u8C61");
+      }
+    }
+  });
+  return Object.keys(data);
+}
+function validateState(state, add) {
+  if (state === void 0) return [];
+  if (typeof state !== "object" || state === null || Array.isArray(state)) {
+    add("state", "state \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return [];
+  }
+  return Object.keys(state);
+}
+function validateDerived(derived, dataKeys, stateKeys, add) {
+  if (derived === void 0) return;
+  if (typeof derived !== "object" || derived === null || Array.isArray(derived)) {
+    add("derived", "derived \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  Object.keys(derived).forEach((key) => {
+    const item = derived[key] || {};
+    if (typeof item.list !== "string") {
+      add(`derived.${key}.list`, "list \u5FC5\u987B\u662F data \u4E2D\u7684\u6570\u7EC4\u5B57\u6BB5\u540D");
+    } else if (dataKeys.indexOf(item.list) === -1) {
+      add(`derived.${key}.list`, `data \u4E2D\u4E0D\u5B58\u5728 "${item.list}"`);
+    }
+    if (typeof item.indexBy !== "string") {
+      add(`derived.${key}.indexBy`, "indexBy \u5FC5\u987B\u662F state \u4E2D\u7684\u5B57\u6BB5\u540D");
+    } else if (stateKeys.indexOf(item.indexBy) === -1) {
+      add(`derived.${key}.indexBy`, `state \u4E2D\u4E0D\u5B58\u5728 "${item.indexBy}"`);
+    }
+  });
+}
+function validateNode(node, path, layout, ctx) {
+  const { add, warn } = ctx;
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    add(path, "\u8282\u70B9\u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (NODE_TYPES.indexOf(node.type) === -1) {
+    add(`${path}.type`, `\u672A\u77E5\u8282\u70B9\u7C7B\u578B "${node.type}"\uFF0C\u53EF\u7528\uFF1A${NODE_TYPES.join(" / ")}`);
+    return;
+  }
+  if (layout === "absolute" && !Array.isArray(node.rect)) {
+    add(`${path}.rect`, "\u5904\u4E8E\u7EDD\u5BF9\u5B9A\u4F4D\u5BB9\u5668\u4E2D\uFF0C\u5FC5\u987B\u63D0\u4F9B rect: [x, y, w, h]");
+  }
+  if (node.rect !== void 0) {
+    if (!Array.isArray(node.rect)) {
+      add(`${path}.rect`, "rect \u5FC5\u987B\u662F [x, y, w, h] \u6570\u7EC4");
+    } else {
+      node.rect.forEach((value, index) => {
+        if (value !== void 0 && value !== null && !checkLength(value)) {
+          add(`${path}.rect[${index}]`, `"${value}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6\uFF0C\u652F\u6301\u6570\u5B57(px) / '100%' / 'auto' \u7B49`);
+        }
+      });
+    }
+  }
+  if (node.style) {
+    Object.keys(node.style).forEach((key) => {
+      if (ALLOWED_STYLE_KEYS.indexOf(key) === -1) {
+        warn(`${path}.style.${key}`, `\u6837\u5F0F\u5C5E\u6027 "${key}" \u4E0D\u5728\u767D\u540D\u5355\u5185\uFF0C\u6E32\u67D3\u65F6\u4F1A\u88AB\u5FFD\u7565`);
+        return;
+      }
+      if (LENGTH_STYLE_KEYS.indexOf(key) > -1 && !checkLength(node.style[key])) {
+        add(
+          `${path}.style.${key}`,
+          `"${node.style[key]}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6\uFF0C\u652F\u6301\u6570\u5B57(px) / '100%' / 'auto' \u7B49`
+        );
+      }
+      if (key === "aspectRatio" && !checkAspectRatio(node.style[key])) {
+        add(`${path}.style.aspectRatio`, "aspectRatio \u8981\u5199\u6210 '750 / 200' \u6216 1.5 \u8FD9\u6837\u7684\u5BBD\u9AD8\u6BD4");
+      }
+    });
+  }
+  if (node.visibleWhen !== void 0) {
+    if (typeof node.visibleWhen !== "string") {
+      add(`${path}.visibleWhen`, "visibleWhen \u5FC5\u987B\u662F\u8868\u8FBE\u5F0F\u5B57\u7B26\u4E32");
+    } else {
+      const error = check(node.visibleWhen);
+      if (error) add(`${path}.visibleWhen`, `\u8868\u8FBE\u5F0F\u6709\u8BEF\uFF1A${error}`);
+    }
+  }
+  if (node.action !== void 0) validateAction(node.action, `${path}.action`, ctx);
+  validateNodeByType(node, path, ctx);
+}
+function validateNodeByType(node, path, ctx) {
+  const { add } = ctx;
+  if (node.type === "image" && !node.src) {
+    add(`${path}.src`, "image \u5FC5\u987B\u63D0\u4F9B src");
+  }
+  if (node.type === "text" && node.content === void 0) {
+    add(`${path}.content`, "text \u5FC5\u987B\u63D0\u4F9B content");
+  }
+  if (node.type === "button" && node.text === void 0) {
+    add(`${path}.text`, "button \u5FC5\u987B\u63D0\u4F9B text");
+  }
+  if (node.type === "tabs") {
+    if (typeof node.bind !== "string") {
+      add(`${path}.bind`, "tabs \u5FC5\u987B\u63D0\u4F9B bind\uFF08data \u4E2D\u7684\u6570\u7EC4\u5B57\u6BB5\u540D\uFF09");
+    }
+    if (typeof node.stateKey !== "string") add(`${path}.stateKey`, "tabs \u5FC5\u987B\u63D0\u4F9B stateKey");
+    if (node.labelField !== void 0 && typeof node.labelField !== "string") {
+      add(`${path}.labelField`, "labelField \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+    }
+  }
+  if (node.type === "countdown") {
+    if (!node.to) add(`${path}.to`, "countdown \u5FC5\u987B\u63D0\u4F9B to\uFF08\u7ED3\u675F\u65F6\u95F4\uFF09");
+    if (node.precision !== void 0 && ["s", "cs"].indexOf(node.precision) === -1) {
+      add(`${path}.precision`, "precision \u53EA\u80FD\u662F 's'\uFF08\u6BCF\u79D2\uFF09\u6216 'cs'\uFF08\u5398\u79D2\uFF0C\u9010\u5E27\u5237\u65B0\uFF09");
+    }
+    if (node.children !== void 0 && !Array.isArray(node.children)) {
+      add(`${path}.children`, "children \u5FC5\u987B\u662F\u6570\u7EC4");
+    } else {
+      (node.children || []).forEach((child, index) => {
+        validateNode(child, `${path}.children[${index}]`, "flow", ctx);
+      });
+    }
+  }
+  if (node.type === "repeat") {
+    if (typeof node.bind !== "string") add(`${path}.bind`, "repeat \u5FC5\u987B\u63D0\u4F9B bind");
+    if (!node.template) {
+      add(`${path}.template`, "repeat \u5FC5\u987B\u63D0\u4F9B template");
+    } else {
+      validateNode(node.template, `${path}.template`, "flow", ctx);
+    }
+  }
+  if (CONTAINER_TYPES.indexOf(node.type) > -1) {
+    const childLayout = node.type === "box" ? "absolute" : "flow";
+    if (node.children !== void 0 && !Array.isArray(node.children)) {
+      add(`${path}.children`, "children \u5FC5\u987B\u662F\u6570\u7EC4");
+    } else {
+      (node.children || []).forEach((child, index) => {
+        validateNode(child, `${path}.children[${index}]`, childLayout, ctx);
+      });
+    }
+  }
+}
+function validateAction(action, path, ctx) {
+  const { add } = ctx;
+  if (!action || typeof action !== "object" || Array.isArray(action)) {
+    add(path, "action \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (ACTION_TYPES.indexOf(action.type) === -1) {
+    add(`${path}.type`, `\u672A\u77E5\u52A8\u4F5C "${action.type}"\uFF0C\u53EF\u7528\uFF1A${ACTION_TYPES.join(" / ")}`);
+    return;
+  }
+  if (action.type === "navigate" && !action.url) {
+    add(`${path}.url`, "navigate \u5FC5\u987B\u63D0\u4F9B url");
+  }
+  if (action.type === "setState" && typeof action.key !== "string") {
+    add(`${path}.key`, "setState \u5FC5\u987B\u63D0\u4F9B key");
+  }
+  if (action.type === "track" && !action.event) {
+    add(`${path}.event`, "track \u5FC5\u987B\u63D0\u4F9B event");
+  }
+  if (action.type === "call" && !action.name) {
+    add(`${path}.name`, "call \u5FC5\u987B\u63D0\u4F9B name\uFF08\u5BBF\u4E3B\u6CE8\u518C\u7684\u65B9\u6CD5\u540D\uFF09");
+  }
+  if (action.type === "open") {
+    if (!action.view) {
+      add(`${path}.view`, "open \u5FC5\u987B\u63D0\u4F9B view\uFF08\u8981\u6253\u5F00\u7684\u89C6\u56FE\u540D\uFF09");
+    } else if (ctx.viewNames && ctx.viewNames.indexOf(action.view) === -1) {
+      add(`${path}.view`, `views \u91CC\u4E0D\u5B58\u5728\u89C6\u56FE "${action.view}"`);
+    }
+    if (action.mode !== void 0 && ["stack", "replace"].indexOf(action.mode) === -1) {
+      add(`${path}.mode`, "mode \u53EA\u80FD\u662F 'stack'\uFF08\u9ED8\u8BA4\uFF0C\u53E0\u4E00\u5C42\uFF09\u6216 'replace'\uFF08\u6362\u6389\u5F53\u524D\u5C42\uFF09");
+    }
+  }
+  if (action.type === "sequence") {
+    if (!Array.isArray(action.actions)) {
+      add(`${path}.actions`, "sequence \u5FC5\u987B\u63D0\u4F9B actions \u6570\u7EC4");
+    } else {
+      action.actions.forEach(
+        (item, index) => validateAction(item, `${path}.actions[${index}]`, ctx)
+      );
+    }
+  }
+}
+function formatIssues(issues) {
+  return issues.map((item) => item.path ? `${item.path}: ${item.message}` : item.message).join("\n");
+}
+
+exports.ACTION_TYPES = ACTION_TYPES;
+exports.ALLOWED_STYLE_KEYS = ALLOWED_STYLE_KEYS;
+exports.CLOSE_POSITIONS = CLOSE_POSITIONS;
+exports.DSL_VERSION = DSL_VERSION;
+exports.NODE_TYPES = NODE_TYPES;
+exports.SINGLE_VIEW_NAME = SINGLE_VIEW_NAME;
+exports.check = check;
+exports.computeParts = computeParts;
+exports.createRuntime = createRuntime;
+exports.evaluate = evaluate;
+exports.formatIssues = formatIssues;
+exports.formatParts = formatParts;
+exports.interpolate = interpolate;
+exports.interpolateDeep = interpolateDeep;
+exports.isLength = isLength;
+exports.normalizeViews = normalizeViews;
+exports.parseEndTime = parseEndTime;
+exports.safeImageUrl = safeImageUrl;
+exports.safeUrl = safeUrl;
+exports.toCssStyle = toCssStyle;
+exports.toLength = toLength;
+exports.validate = validate;