bobe 0.0.10 → 0.0.12

package/dist/index.umd.js

@@ -23,35 +23,116 @@
     LogicType2[LogicType2["Component"] = 16] = "Component";
     LogicType2[LogicType2["Fragment"] = 32] = "Fragment";
     LogicType2[LogicType2["Root"] = 64] = "Root";
+    LogicType2[LogicType2["Real"] = 128] = "Real";
     return LogicType2;
   })(LogicType || {});
+  const Logical = 1 /* If */ | 2 /* ElseIf */ | 4 /* Else */ | 8 /* For */;
+  var NodeType = /* @__PURE__ */ ((NodeType2) => {
+    NodeType2[NodeType2["Logic"] = Logical] = "Logic";
+    NodeType2[NodeType2["Real"] = 128 /* Real */] = "Real";
+    NodeType2[NodeType2["Component"] = 16 /* Component */] = "Component";
+    return NodeType2;
+  })(NodeType || {});
   var TerpEvt = /* @__PURE__ */ ((TerpEvt2) => {
     TerpEvt2["AllAttrGot"] = "all-attr-got";
     TerpEvt2["HandledComponentNode"] = "handled-component-node";
     return TerpEvt2;
   })(TerpEvt || {});
+  const IsAnchor = /* @__PURE__ */ Symbol("is-anchor");
 
-  var __defProp = Object.defineProperty;
-  var __defProps = Object.defineProperties;
-  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __propIsEnum = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues = (a, b) => {
+  class TypedStack {
+    constructor() {
+      this.top = null;
+      // 存储每种类型最近一次出现的包装单元引用
+      // 使用 Record 来动态支持不同的类型标签
+      this.lastNodes = {};
+      this.length = 0;
+    }
+    /**
+     * @param rawNode 原始节点数据
+     * @param type 节点类型
+     */
+    push(rawNode, type) {
+      var _a;
+      const newNode = {
+        data: rawNode,
+        type,
+        prev: this.top,
+        prevSameType: (_a = this.lastNodes[type]) != null ? _a : null
+      };
+      this.top = newNode;
+      this.length++;
+      this.lastNodes[type] = newNode;
+    }
+    /**
+     * 出栈操作
+     * @returns 原始节点数据或 null
+     */
+    pop() {
+      if (!this.top) return null;
+      const popped = this.top;
+      this.lastNodes[popped.type] = popped.prevSameType;
+      this.top = popped.prev;
+      this.length--;
+      return popped.data;
+    }
+    /**
+     * O(1) 获取栈顶节点的前一个同类型节点
+     */
+    getPrevSameType() {
+      if (!this.top || !this.top.prevSameType) {
+        return null;
+      }
+      return this.top.prevSameType.data;
+    }
+    findPrevSameType(cb) {
+      if (!this.top) {
+        return null;
+      }
+      let point = this.top.prevSameType;
+      while (point) {
+        if (cb(point.data)) {
+          return point.data;
+        }
+        point = point.prevSameType;
+      }
+      return null;
+    }
+    /**
+     * 获取当前栈顶的类型
+     */
+    get peekType() {
+      return this.top ? this.top.type : null;
+    }
+    /**
+     * 获取栈顶元素
+     */
+    peek() {
+      return this.top.data;
+    }
+  }
+
+  var __defProp$1 = Object.defineProperty;
+  var __defProps$1 = Object.defineProperties;
+  var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$1 = (a, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    if (__getOwnPropSymbols)
-      for (var prop of __getOwnPropSymbols(b)) {
-        if (__propIsEnum.call(b, prop))
-          __defNormalProp(a, prop, b[prop]);
+      if (__hasOwnProp$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    if (__getOwnPropSymbols$1)
+      for (var prop of __getOwnPropSymbols$1(b)) {
+        if (__propIsEnum$1.call(b, prop))
+          __defNormalProp$1(a, prop, b[prop]);
       }
     return a;
   };
-  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
   const tap = new bobeShared.BaseEvent();
-  class Terp {
+  class Interpreter {
     constructor(tokenizer) {
       this.tokenizer = tokenizer;
       /** 模板字符串动态节点的占位符 */
@@ -60,7 +141,6 @@
       this.data = {};
       /** 模板字符串动态节点索引 */
       this.hookI = 0;
-      this.stack = [];
       this._hook = (props) => {
         const value = this.tokenizer.token.value;
         const isDynamicHook = this.tokenizer.token.type & TokenType.InsertionExp;
@@ -68,7 +148,7 @@
         const hookType = isDynamicHook ? "dynamic" : isStaticHook ? "static" : void 0;
         if (this.hook && isStaticHook) {
           const hookI = Number(value.slice(this.HookId.length));
-          const res = this.hook(__spreadProps(__spreadValues({}, props), {
+          const res = this.hook(__spreadProps$1(__spreadValues$1({}, props), {
             HookId: this.HookId,
             i: hookI
           }));
@@ -80,123 +160,115 @@
         return [hookType, value];
       };
     }
-    // /** program 要挂载的父节点位置 */
-    // root: any;
-    // /** program 挂载的前置节点 */
-    // anchor: any;
-    program() {
-      const root = {
+    isLogicNode(node) {
+      return node && node.__logicType & Logical;
+    }
+    program(root, before) {
+      var _a;
+      const componentNode = {
         __logicType: LogicType.Component,
-        store: this.data,
-        realList: [],
-        directList: []
+        realParent: root,
+        store: new aoye.Store()
       };
       this.tokenizer.consume();
-      let current;
-      let prevSibling;
-      this.stack = [{ node: root, prevSibling }];
+      const stack = new TypedStack();
+      stack.push({ node: root, prev: null }, NodeType.Real);
+      const ctx = {
+        realParent: root,
+        prevSibling: before,
+        current: null,
+        stack,
+        before
+      };
+      const rootPulling = aoye.getPulling();
       while (1) {
         if (this.tokenizer.isEof()) {
-          this.handleInsert(root, current, root.realList[root.realList.length - 1]);
+          if (!ctx.prevSibling) ctx.prevSibling = before;
+          this.handleInsert(root, ctx.current, ctx.prevSibling, componentNode);
           break;
         }
         const token = this.tokenizer.token;
         if (token.type & TokenType.Indent) {
           this.tokenizer.consume();
-          this.stack.push({
-            prevSibling,
-            node: current
-          });
-          prevSibling = null;
-          current = this.declaration();
+          const isLogicNode = this.isLogicNode(ctx.current);
+          stack.push(
+            {
+              node: ctx.current,
+              prev: ctx.prevSibling
+            },
+            ctx.current.__logicType ? isLogicNode ? NodeType.Logic : NodeType.Component : NodeType.Real
+          );
+          if (ctx.current.__logicType) {
+            if (isLogicNode) {
+              aoye.setPulling(ctx.current.effect.ins);
+            }
+          } else {
+            ctx.realParent = ctx.current;
+            ctx.prevSibling = null;
+          }
+          ctx.current = this.declaration(ctx);
           continue;
         }
-        if (current) {
-          if (this.stack.length > 1) {
-            const parent = this.stack[this.stack.length - 1].node;
-            this.handleInsert(parent, current, prevSibling);
-          } else {
-            this.handleInsert(root, current, prevSibling);
+        if (ctx.current) {
+          if (stack.length === 1 && !ctx.prevSibling) {
+            ctx.prevSibling = before;
           }
+          this.handleInsert(ctx.realParent, ctx.current, ctx.prevSibling);
         }
         if (this.tokenizer.token.type & TokenType.Dedent) {
           this.tokenizer.consume();
-          const { node: parent, prevSibling: prevParent } = this.stack.pop();
-          prevSibling = prevParent;
-          current = parent;
+          const { node: parent, prev } = stack.peek();
+          if (!parent.__logicType) {
+            const prevSameType = stack.getPrevSameType();
+            ctx.realParent = prevSameType == null ? void 0 : prevSameType.node;
+          } else {
+            if (this.isLogicNode(parent)) {
+              const parentLogic = (_a = stack.getPrevSameType()) == null ? void 0 : _a.node;
+              if (parentLogic) {
+                aoye.setPulling(parentLogic.effect.ins);
+              } else {
+                aoye.setPulling(rootPulling);
+              }
+            }
+          }
+          stack.pop();
+          ctx.prevSibling = prev;
+          ctx.current = parent;
         } else {
-          prevSibling = current;
-          current = this.declaration();
+          ctx.prevSibling = ctx.current || ctx.prevSibling;
+          ctx.current = this.declaration(ctx);
         }
       }
-      return root;
+      return componentNode;
+    }
+    insertAfterAnchor(ctx) {
+      const { realParent, prevSibling, stack, before } = ctx;
+      const afterAnchor = this.createAnchor();
+      ctx.prevSibling = stack.length === 1 && !prevSibling ? before : prevSibling;
+      this.handleInsert(realParent, afterAnchor, prevSibling);
+      return afterAnchor;
     }
     /** 处理
-     *                   是逻辑                         是普通
-     * 父节点  将子节点们插入到 realList          调用 insert 方法挨个插入子节点
-     * 子节点  将其下 realList 插入到父节点       将本节点插入父节点
+     *                    是逻辑                               是普通
+     * 父节点       将子节点加入 directList         调用 insert 方法挨个插入子节点
+     * 子节点           仅插入到父逻辑节点              将本节点插入父节点
+     * 理论上父节点不能是一个 逻辑节点，遇到if 时 Terp 会重新执行 program 这种情况下，会指定 root 为真实 dom
      */
-    handleInsert(parent, child, prevSibling) {
-      let insertFn = this.insert.bind(this);
-      if (parent.__logicType) {
-        insertFn = (parent2, child2, prevSibling2) => {
-          parent2.realList.splice(parent2.realList.indexOf(prevSibling2) + 1, 0, child2);
-        };
-      }
-      if (child.__logicType) {
-        const realList = child.realList;
-        for (let i = realList.length; i--; ) {
-          const item = realList[i];
-          insertFn(parent, item, prevSibling);
+    handleInsert(parent, child, prev, parentComponent) {
+      if (!child.__logicType) {
+        if (!prev || !prev.__logicType) {
+          this.insertAfter(parent, child, prev);
+        } else {
+          const before = prev.realAfter;
+          this.insertAfter(parent, child, before);
         }
       } else {
-        insertFn(parent, child, prevSibling);
-      }
-    }
-    /**
-     * @deprecated
-     * 节点列表：
-     * 可以是一个节点，也可以跟随更多节点
-     * <nodeList> ::= <node> <nodeList> <EOF|Dedent>
-     *               |
-     */
-    nodeList(parent) {
-      let _node;
-      let prevSibling;
-      let prevItem;
-      while (1) {
-        if (this.tokenizer.isEof()) {
-          return;
-        }
-        if (this.tokenizer.token.type & TokenType.Dedent) {
-          this.tokenizer.consume();
-          return;
-        }
-        _node = this.node();
-        const insert = parent.__logicType ? this.defaultInsert : this.insert.bind(this);
-        parent.__logicType ? this.defaultRemove : this.remove.bind(this);
-        if (!_node.__logicType) {
-          const realPrev = this.getPrevRealSibling(prevSibling);
-          const currItem = insert(parent, _node, realPrev, prevItem);
-          prevItem = currItem;
-          prevSibling = _node;
-          continue;
-        }
-        if (prevSibling) {
-          _node.anchor = prevSibling;
-        } else if (parent.__logicType) {
-          _node.anchor = parent;
-        } else ;
-        if (_node.child && _node.condition()) {
-          let item = _node.child;
-          while (item != null) {
-            const { value: child } = item;
-            const realPrev = this.getPrevRealSibling(prevSibling);
-            const currItem = insert(parent, child, realPrev, prevItem);
-            item = item.next;
-            prevItem = currItem;
-            prevSibling = child;
-          }
+        const childCmp = child;
+        childCmp.realParent = parent;
+        if (prev.__logicType) {
+          childCmp.realBefore = prev.realAfter;
+        } else {
+          childCmp.realBefore = prev;
         }
       }
     }
@@ -213,33 +285,20 @@
         point = point.anchor;
       }
     }
-    /**
-     * 单个节点：
-     * 由声明部分和（可选的）子节点块组成
-     * <node> ::= <declaration> <childrenBlockOpt>
-     *  */
-    node() {
-      const _declaration = this.declaration();
-      if (_declaration.__logicType & LogicType.If && !_declaration.condition()) {
-        return _declaration;
-      }
-      this.childrenBlockOpt(_declaration);
-      return _declaration;
-    }
     /**
      * 声明部分：
      * 包含首行定义和（可选的）多行属性扩展
      * <declaration> ::= <tagName=token> <headerLine> <extensionLines>
      *  */
-    declaration() {
+    declaration(ctx) {
       const [hookType, value] = this._hook({});
       let _node;
       if (value === "if") {
-        return this.ifDeclaration();
+        return this.ifDeclaration(ctx);
       } else if (hookType) {
         if (hookType === "static") {
           if (typeof value === "function" && value.prototype instanceof aoye.Store) {
-            _node = this.componentDeclaration(value);
+            _node = this.componentDeclaration(value, ctx);
           } else if (typeof value === "function") {
             _node = this.fragmentDeclaration(value);
           } else {
@@ -266,8 +325,7 @@
     fragmentDeclaration(renderFragment) {
       const fragmentNode = {
         __logicType: LogicType.Fragment,
-        directList: [],
-        realList: []
+        realParent: null
       };
       renderFragment.call(this.data, this.opt, { data: this.data, root: "", anchor: "" });
       return fragmentNode;
@@ -295,7 +353,7 @@
         this.setProp(node, key, value, hookI);
       }
     }
-    componentDeclaration(Component) {
+    componentDeclaration(Component, ctx) {
       const child = Component.new();
       const prevOnePropParsed = this.onePropParsed;
       this.onePropParsed = (node, key, value, valueIsMapKey, hookI) => {
@@ -310,36 +368,66 @@
           child[aoye.Keys.Raw][key] = value;
         }
       };
+      const afterAnchor = this.insertAfterAnchor(ctx);
       tap.once(TerpEvt.AllAttrGot, () => {
+        const parent = ctx.realParent;
+        const prev = ctx.prevSibling;
         this.onePropParsed = prevOnePropParsed;
-        const root = child["ui"](this.opt, { data: child });
-        tap.emit(TerpEvt.HandledComponentNode, root);
+        const componentNode = child["ui"](this.opt, { data: child }, parent, prev);
+        componentNode.realAfter = afterAnchor;
+        tap.emit(TerpEvt.HandledComponentNode, componentNode);
       });
       return { __logicType: LogicType.Component };
     }
-    ifDeclaration() {
+    ifDeclaration(ctx) {
       this.tokenizer.consume();
-      const [isHook, value] = this._hook({});
+      const [hookType, value] = this._hook({});
       const ifNode = {
         __logicType: LogicType.If,
-        condition: value,
-        directList: [],
-        realList: [],
         snapshot: this.tokenizer.snapshot(),
+        condition: null,
+        realParent: null,
         isFirstRender: true,
-        watcher: null,
-        anchor: null
+        effect: null
       };
-      ifNode.watcher = aoye.effect(
+      const valueIsMapKey = Reflect.has(this.data[aoye.Keys.Raw], value);
+      let signal;
+      if (valueIsMapKey) {
+        aoye.runWithPulling(() => this.data[value], null);
+        const { cells } = this.data[aoye.Keys.Meta];
+        signal = cells.get(value);
+      } else {
+        const fn = new Function("data", `let v;with(data){v=${value}};return v;`).bind(void 0, this.data);
+        signal = aoye.$(fn);
+      }
+      ifNode.condition = signal;
+      ifNode.realAfter = this.insertAfterAnchor(ctx);
+      ifNode.effect = aoye.effect(
         ({ val }) => {
           if (val) {
-            this.tokenizer.consume();
-            this.tokenizer.consume();
+            if (ifNode.isFirstRender) {
+              this.tokenizer.consume();
+              this.tokenizer.consume();
+            } else {
+              this.tokenizer.resume(ifNode.snapshot);
+              this.program(ifNode.realParent, ifNode.realBefore);
+            }
           } else {
-            this.tokenizer.skip();
+            if (ifNode.isFirstRender) {
+              this.tokenizer.skip();
+            } else {
+              const { realBefore, realAfter, realParent } = ifNode;
+              let point = this.nextSib(realBefore);
+              while (point !== realAfter) {
+                const next = this.nextSib(point);
+                this.remove(point, realParent, realBefore);
+                point = next;
+              }
+            }
           }
+          ifNode.isFirstRender = false;
         },
-        [value]
+        [signal]
       );
       return ifNode;
     }
@@ -403,19 +491,6 @@
         this.tokenizer.consume();
       }
     }
-    /** 子节点块：
-     * 必须被缩进包裹
-     * <childrenBlockOpt> ::= INDENT <nodeList>
-     *                        | ε  /* 空（表示叶子节点，没有孩子）
-     *  */
-    childrenBlockOpt(parent) {
-      if (!(this.tokenizer.token.type & TokenType.Indent)) {
-        return [];
-      }
-      this.tokenizer.consume();
-      const list = this.nodeList(parent);
-      return list;
-    }
     config(opt) {
       Object.assign(this, opt);
       this.opt = opt;
@@ -423,28 +498,47 @@
     createNode(name) {
       return {
         name,
-        props: {}
+        props: {},
+        nextSibling: null
       };
     }
-    insert(parent, node, prevSibling, prevItem) {
-      return this.defaultInsert(parent, node, prevSibling, prevItem);
+    nextSib(node) {
+      return node.nextSibling;
     }
-    defaultInsert(parent, node, prevSibling, prevItem) {
-      if (prevSibling) {
-        const children = parent.children;
-        const insertI = children.findIndex((item) => item === prevSibling);
-        children.splice(insertI + 1, 0, node);
+    _createAnchor() {
+      const anchor = this.createAnchor();
+      anchor[IsAnchor] = true;
+      return anchor;
+    }
+    createAnchor() {
+      return {
+        name: "anchor",
+        nextSibling: null
+      };
+    }
+    insertAfter(parent, node, prev) {
+      return this.defaultInsert(parent, node, prev);
+    }
+    defaultInsert(parent, node, prev) {
+      if (prev) {
+        const next = prev.nextSibling;
+        prev.nextSibling = node;
+        node.nextSibling = next;
       } else {
-        parent.children = [node];
+        parent.firstChild = node;
       }
     }
-    remove(parent, node, prevSibling, prevItem) {
-      return this.defaultRemove(parent, node, prevSibling, prevItem);
+    remove(node, parent, prev) {
+      return this.defaultRemove(node, parent, prev);
     }
     // TODO: 默认改成 prevItem
-    defaultRemove(parent, node, prevSibling, prevItem) {
-      if (parent.children) {
-        parent.children.splice(parent.children.indexOf(node), 1);
+    defaultRemove(node, parent, prevSibling) {
+      const next = node.nextSibling;
+      if (prevSibling) {
+        prevSibling.nextSibling = next;
+      }
+      if (parent.firstChild === node) {
+        parent.firstChild = next;
       }
     }
     setProp(node, key, value, hookI) {
@@ -464,7 +558,496 @@
     }
   }
 
-  exports.Terp = Terp;
+  const _Tokenizer = class _Tokenizer {
+    constructor() {
+      /** 缩进大小 默认 2 */
+      this.TabSize = 2;
+      /** 缩进字符 */
+      this.Tab = Array.from({ length: this.TabSize }, () => " ").join("");
+      /** 匹配标识符 */
+      this.IdExp = /[\d\w\/]/;
+      /** 回车后需要判断缩进 */
+      this.needIndent = false;
+      /** 用于跳过第一个节点前的空白字符串，以及生成基础缩进 */
+      this.isFirstToken = true;
+      /** 记录历史缩进的长度，相对于行首 */
+      this.dentStack = [0];
+      /** 当前字符 index */
+      this.i = 0;
+      this.handledTokens = [];
+      /**
+       * 有些标识符能产生多个 token
+       * 例如 dedent
+       * parent1
+       *   child
+       *     subChild
+       * parent2 <- 产生两个 dedent
+       */
+      this.waitingTokens = new bobeShared.Queue();
+    }
+    consume() {
+      const token = this.token;
+      this.nextToken();
+      return token;
+    }
+    // /** 恢复至某一个现场，进行 token 重算 */
+    resume(_snapshot) {
+      this.token = void 0;
+      this.needIndent = false;
+      this.isFirstToken = true;
+      this.dentStack = [0];
+      Object.assign(this, _snapshot);
+    }
+    snapshot() {
+      return {
+        i: this.i,
+        waitingTokens: this.waitingTokens.clone()
+      };
+    }
+    skip() {
+      const logicDentLen = this.dentStack[this.dentStack.length - 1];
+      let needIndent = false;
+      let skipFragment = ``;
+      this.token = void 0;
+      while (1) {
+        const char = this.char;
+        if (char === "\n") {
+          needIndent = true;
+          skipFragment += char;
+          this.next();
+          continue;
+        }
+        if (!needIndent) {
+          skipFragment += char;
+          this.next();
+          continue;
+        }
+        needIndent = false;
+        const { value, isEmptyLine } = this.getDentValue();
+        const currLen = value.length;
+        if (isEmptyLine) continue;
+        if (currLen > logicDentLen) {
+          skipFragment += value;
+        } else {
+          for (let i = this.dentStack.length - 1; i >= 0; i--) {
+            const expLen = this.dentStack[i];
+            if (currLen === expLen) break;
+            if (currLen > expLen) {
+              throw SyntaxError(`\u7F29\u8FDB\u9519\u8BEF\uFF0C\u7F29\u8FDB\u957F\u5EA6\u4E0D\u5339\u914D`);
+            }
+            if (this.shorterThanBaseDentEof()) {
+              break;
+            }
+            this.dentStack.pop();
+            if (!this.token) {
+              this.setToken(TokenType.Dedent, String(expLen));
+            } else {
+              this.waitingTokens.push({
+                type: TokenType.Dedent,
+                typeName: TokenType[TokenType.Dedent],
+                value: String(expLen)
+              });
+            }
+          }
+          break;
+        }
+      }
+      if (!this.token) {
+        this.nextToken();
+      }
+      return skipFragment;
+    }
+    setCode(code) {
+      this.code = "\n" + code.trimEnd() + `
+${_Tokenizer.EofId}`;
+    }
+    tokenize() {
+      var _a, _b;
+      do {
+        this.nextToken();
+        console.log("token:", TokenType[(_a = this.token) == null ? void 0 : _a.type], JSON.stringify(((_b = this.token) == null ? void 0 : _b.value) || ""));
+      } while (!this.isEof());
+    }
+    isEof() {
+      if (!this.token) return false;
+      return this.token.type & TokenType.Identifier && this.token.value === _Tokenizer.EofId;
+    }
+    get char() {
+      return this.code[this.i];
+    }
+    get prev() {
+      return this.code[this.i - 1];
+    }
+    get after() {
+      return this.code[this.i + 1];
+    }
+    next() {
+      const prev = this.code[this.i];
+      this.i++;
+      const curr = this.code[this.i];
+      return [prev, curr];
+    }
+    setToken(type, value) {
+      this.token = {
+        type,
+        typeName: TokenType[type],
+        value
+      };
+      this.isFirstToken = false;
+    }
+    testId(value) {
+      if (typeof value !== "string") return false;
+      return this.IdExp.test(value);
+    }
+    nextToken() {
+      try {
+        if (this.isEof()) {
+          return this.token;
+        }
+        this.token = void 0;
+        if (this.waitingTokens.len) {
+          const item = this.waitingTokens.shift();
+          this.setToken(item.type, item.value);
+          return this.token;
+        }
+        outer: while (1) {
+          if (this.needIndent) {
+            this.dent();
+          } else {
+            let { char } = this;
+            switch (char) {
+              case "	":
+              case " ":
+                break;
+              // 找后续所有 newLine
+              case "\n":
+                this.newLine();
+                this.needIndent = true;
+                break;
+              case "=":
+                this.assignment();
+                break;
+              case "|":
+                this.pipe();
+                break;
+              case "'":
+              case '"':
+                this.str(char);
+                break;
+              case "{":
+                this.brace();
+                break;
+              case "$":
+                const handled = this.dynamic(char);
+                if (handled) break;
+              default:
+                if (bobeShared.isNum(char)) {
+                  this.number(char);
+                  break;
+                }
+                if (this.testId(char)) {
+                  this.identifier(char);
+                }
+                break;
+            }
+            this.next();
+          }
+          if (this.token) {
+            break;
+          }
+        }
+        return this.token;
+      } catch (error) {
+        console.error(error);
+      } finally {
+        this.handledTokens.push(this.token);
+      }
+    }
+    assignment() {
+      this.setToken(TokenType.Assign, "=");
+    }
+    pipe() {
+      this.setToken(TokenType.Pipe, "|");
+    }
+    dynamic(char) {
+      let nextC = this.after;
+      if (nextC !== "{") {
+        return false;
+      }
+      this.next();
+      let value = "${";
+      let innerBrace = 0;
+      while (1) {
+        nextC = this.after;
+        value += nextC;
+        this.next();
+        if (nextC === "{") {
+          innerBrace++;
+        }
+        if (nextC === "}") {
+          if (!innerBrace) {
+            break;
+          }
+          innerBrace--;
+        }
+      }
+      this.setToken(TokenType.Identifier, value);
+      return true;
+    }
+    brace() {
+      let inComment, inString, count = 0, value = "", backslashCount = 0;
+      while (1) {
+        const char = this.char;
+        const nextChar = this.after;
+        if (inComment === "single" && char === "\n") {
+          inComment = null;
+        } else if (inComment === "multi" && char === "*" && nextChar === "/") {
+          inComment = null;
+          value += this.next()[0];
+        } else if (inString) {
+          if (char === inString && backslashCount % 2 === 0) {
+            inString = null;
+          }
+          backslashCount = char === "\\" ? backslashCount + 1 : 0;
+        } else {
+          if (char === "/" && nextChar === "/") {
+            inComment = "single";
+            value += this.next()[0];
+          } else if (char === "/" && nextChar === "*") {
+            inComment = "multi";
+            value += this.next()[0];
+          } else if (char === "'" || char === '"' || char === "`") {
+            inString = char;
+          } else if (char === "{") {
+            count++;
+          } else if (char === "}") {
+            count--;
+          }
+        }
+        if (count === 0 && inString == null && inComment == null) {
+          this.setToken(TokenType.InsertionExp, value.slice(1));
+          return;
+        }
+        value += this.next()[0];
+      }
+    }
+    newLine() {
+      let value = "\n";
+      let nextC;
+      while (1) {
+        nextC = this.after;
+        if (nextC !== "\n") {
+          break;
+        }
+        value += nextC;
+        this.next();
+      }
+      if (this.isFirstToken) {
+        return;
+      }
+      this.setToken(TokenType.NewLine, value);
+    }
+    getDentValue() {
+      let value = "";
+      let nextC;
+      let isEmptyLine = false;
+      while (1) {
+        const nextChar = this.char;
+        switch (nextChar) {
+          case "	":
+            nextC = this.Tab;
+            break;
+          case " ":
+            nextC = " ";
+            break;
+          case "\n":
+            nextC = "\n";
+            break;
+          default:
+            nextC = "";
+            break;
+        }
+        if (nextC === "\n") {
+          isEmptyLine = true;
+          break;
+        }
+        if (!nextC) {
+          break;
+        }
+        value += nextC;
+        this.next();
+      }
+      return {
+        value,
+        isEmptyLine
+      };
+    }
+    dent() {
+      const { value, isEmptyLine } = this.getDentValue();
+      if (isEmptyLine) {
+        this.needIndent = true;
+        return;
+      }
+      this.needIndent = false;
+      if (this.isFirstToken) {
+        this.dentStack[0] = value.length;
+        return;
+      }
+      let currLen = value.length;
+      const indentHasLen = currLen > 0;
+      const prevLen = this.dentStack[this.dentStack.length - 1];
+      if (currLen > prevLen) {
+        this.dentStack.push(currLen);
+        this.setToken(TokenType.Indent, String(currLen));
+        return indentHasLen;
+      }
+      if (currLen < prevLen) {
+        for (let i = this.dentStack.length; i--; ) {
+          const expLen = this.dentStack[i];
+          if (currLen === expLen) break;
+          if (currLen > expLen) {
+            throw SyntaxError("\u7F29\u8FDB\u5927\u5C0F\u4E0D\u7EDF\u4E00");
+          }
+          if (this.shorterThanBaseDentEof()) {
+            return;
+          }
+          this.dentStack.pop();
+          if (!this.token) {
+            this.setToken(TokenType.Dedent, String(expLen));
+          } else {
+            this.waitingTokens.push({
+              type: TokenType.Dedent,
+              typeName: TokenType[TokenType.Dedent],
+              value: String(expLen)
+            });
+          }
+        }
+        return indentHasLen;
+      }
+      return indentHasLen;
+    }
+    shorterThanBaseDentEof() {
+      const yes = this.dentStack.length === 1;
+      if (yes) {
+        if (!this.token) {
+          this.setToken(TokenType.Identifier, _Tokenizer.EofId);
+        } else {
+          this.waitingTokens.push({
+            type: TokenType.Identifier,
+            typeName: TokenType[TokenType.Identifier],
+            value: _Tokenizer.EofId
+          });
+        }
+      }
+      return yes;
+    }
+    identifier(char) {
+      let value = char;
+      let nextC;
+      while (1) {
+        nextC = this.after;
+        if (!this.testId(nextC)) {
+          break;
+        }
+        value += nextC;
+        this.next();
+      }
+      let realValue = value === "null" ? null : value === "undefined" ? void 0 : value === "false" ? false : value === "true" ? true : value;
+      this.setToken(TokenType.Identifier, realValue);
+    }
+    str(char) {
+      let value = '"';
+      let nextC;
+      let continuousBackslashCount = 0;
+      while (1) {
+        nextC = this.after;
+        value += nextC;
+        const memoCount = continuousBackslashCount;
+        if (nextC === "\\") {
+          continuousBackslashCount++;
+        } else {
+          continuousBackslashCount = 0;
+        }
+        this.next();
+        if (nextC === char && memoCount % 2 === 0) {
+          break;
+        }
+      }
+      this.setToken(TokenType.Identifier, JSON.parse(value.slice(0, -1) + '"'));
+    }
+    number(char) {
+      let value = char;
+      let nextC;
+      while (1) {
+        nextC = this.after;
+        if (!bobeShared.isNum(nextC)) {
+          break;
+        }
+        value += nextC;
+        this.next();
+      }
+      this.setToken(TokenType.Identifier, Number(value));
+    }
+    eof() {
+      this.setToken(TokenType.Eof, "End Of File");
+    }
+  };
+  /** Eof 标识符的值 */
+  _Tokenizer.EofId = `__EOF__${Date.now()}`;
+  let Tokenizer = _Tokenizer;
+
+  var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  function bobe(fragments, ...values) {
+    const ui = function ui2(options, valueOpt, root, before) {
+      const tokenizer = new Tokenizer();
+      const cmp = new Interpreter(tokenizer);
+      Object.assign(cmp, valueOpt);
+      cmp.config(__spreadProps(__spreadValues({}, options), {
+        hook({ i }) {
+          return values[i];
+        },
+        setProp(node, key, value, hookI) {
+          node.props[key] = value;
+        }
+      }));
+      cmp.init(Array.from(fragments));
+      return cmp.program(root, before);
+    };
+    return ui;
+  }
+  function customRender(option) {
+    return function render(Ctor, root) {
+      const store = Ctor.new();
+      return [store["ui"](option, { data: store }, root), store];
+    };
+  }
+
+  exports.bobe = bobe;
+  exports.customRender = customRender;
+  Object.keys(aoye).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+      enumerable: true,
+      get: function () { return aoye[k]; }
+    });
+  });
 
 }));
 //# sourceMappingURL=index.umd.js.map