bobe 0.0.32 → 0.0.33

package/dist/index.umd.js

@@ -1,77 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('aoye'), require('bobe-shared')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'aoye', 'bobe-shared'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Bobe = {}, global.Aoye, global.BobeShared));
-})(this, (function (exports, aoye, bobeShared) { 'use strict';
-
-  function _arrayLikeToArray(r, a) {
-    (null == a || a > r.length) && (a = r.length);
-    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-    return n;
-  }
-  function _arrayWithHoles(r) {
-    if (Array.isArray(r)) return r;
-  }
-  function _iterableToArrayLimit(r, l) {
-    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-    if (null != t) {
-      var e,
-        n,
-        i,
-        u,
-        a = [],
-        f = true,
-        o = false;
-      try {
-        if (i = (t = t.call(r)).next, 0 === l) {
-          if (Object(t) !== t) return;
-          f = !1;
-        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-      } catch (r) {
-        o = true, n = r;
-      } finally {
-        try {
-          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-        } finally {
-          if (o) throw n;
-        }
-      }
-      return a;
-    }
-  }
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function _objectWithoutProperties(e, t) {
-    if (null == e) return {};
-    var o,
-      r,
-      i = _objectWithoutPropertiesLoose(e, t);
-    if (Object.getOwnPropertySymbols) {
-      var n = Object.getOwnPropertySymbols(e);
-      for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
-    }
-    return i;
-  }
-  function _objectWithoutPropertiesLoose(r, e) {
-    if (null == r) return {};
-    var t = {};
-    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-      if (-1 !== e.indexOf(n)) continue;
-      t[n] = r[n];
-    }
-    return t;
-  }
-  function _slicedToArray(r, e) {
-    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
-  }
-  function _unsupportedIterableToArray(r, a) {
-    if (r) {
-      if ("string" == typeof r) return _arrayLikeToArray(r, a);
-      var t = {}.toString.call(r).slice(8, -1);
-      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
-    }
-  }
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bobe-shared'), require('aoye')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'bobe-shared', 'aoye'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Bobe = {}, global.BobeShared, global.Aoye));
+})(this, (function (exports, bobeShared, aoye) { 'use strict';
 
   let TokenType = function (TokenType) {
     TokenType[TokenType["NewLine"] = 1] = "NewLine";
@@ -83,6 +14,7 @@
     TokenType[TokenType["Eof"] = 64] = "Eof";
     TokenType[TokenType["InsertionExp"] = 128] = "InsertionExp";
     TokenType[TokenType["Semicolon"] = 256] = "Semicolon";
+    TokenType[TokenType["StaticInsExp"] = 512] = "StaticInsExp";
     return TokenType;
   }({});
   let FakeType = function (FakeType) {
@@ -113,1427 +45,1922 @@
     return TerpEvt;
   })({});
 
-  class MultiTypeStack {
-    typeTops = {};
-    length = 0;
-    stack = [];
-    push(value, bits) {
-      const newNode = {
-        value,
-        types: bits,
-        prevByType: {}
-      };
-      let bit;
-      while (1) {
-        bit = bits & ~bits + 1;
-        if (!bit) break;
-        bits &= ~bit;
-        newNode.prevByType[bit] = this.typeTops[bit] || undefined;
-        this.typeTops[bit] = newNode;
-      }
-      this.stack[this.length++] = newNode;
-    }
-    pop() {
-      const poppedNode = this.stack[this.length - 1];
-      this.stack[--this.length] = null;
-      if (!poppedNode) return undefined;
-      let bits = poppedNode.types;
-      let bit;
-      while (1) {
-        bit = bits & ~bits + 1;
-        if (!bit) break;
-        bits &= ~bit;
-        this.typeTops[bit] = poppedNode.prevByType[bit];
+  class Tokenizer {
+    TabSize = 2;
+    Tab = Array.from({
+      length: this.TabSize
+    }, () => ' ').join('');
+    static EofId = `__EOF__${Date.now()}`;
+    static DedentId = `__DEDENT__${Date.now()}`;
+    needIndent = false;
+    isFirstToken = true;
+    dentStack = [0];
+    i = 0;
+    line = 0;
+    column = 0;
+    preCol = 0;
+    preI = 0;
+    needLoc = false;
+    handledTokens = [];
+    waitingTokens = new bobeShared.Queue();
+    source = '';
+    constructor(hook, useDedentAsEof) {
+      this.hook = hook;
+      this.useDedentAsEof = useDedentAsEof;
+      if (useDedentAsEof) {
+        this.setToken(TokenType.Indent, '');
+        this.isFirstToken = true;
       }
-      return [poppedNode.value, poppedNode.types];
     }
-    peekByType(cat) {
-      return this.typeTops[cat]?.value;
+    next() {
+      this.i++;
     }
-    peekType() {
-      return this.stack.at(-1).types;
+    getCurrentPos() {
+      return {
+        offset: this.i,
+        line: this.line,
+        column: this.column
+      };
     }
-    peek() {
-      return this.stack.at(-1).value;
+    resume(_snapshot) {
+      this.token = undefined;
+      this.needIndent = false;
+      this.isFirstToken = true;
+      this.dentStack = [0];
+      Object.assign(this, _snapshot);
     }
-  }
-
-  function macInc(arr) {
-    const len = arr.length;
-    let candyLast = [],
-      i = 0;
-    while (i < len) {
-      const it = arr[i];
-      if (it !== -1) {
-        candyLast = [i];
-        break;
+    snapshot(keys) {
+      const snap = {
+        i: this.i,
+        waitingTokens: this.waitingTokens.clone()
+      };
+      if (keys) {
+        for (const k of keys) {
+          snap[k] = this[k];
+          if (k === 'dentStack') {
+            snap[k] = this[k].slice();
+          }
+        }
       }
-      i++;
+      return snap;
     }
-    if (i + 1 >= len) return candyLast;
-    const toPrev = new Int32Array(len);
-    while (i < len) {
-      const target = arr[i];
-      if (target === -1) continue;
-      let start = -1,
-        end = candyLast.length;
-      while (start + 1 < end) {
-        const mid = start + end >> 1;
-        if (arr[candyLast[mid]] < target) {
-          start = mid;
+    skip() {
+      const logicDentLen = this.dentStack[this.dentStack.length - 1];
+      let needIndent = false;
+      let skipFragment = ``;
+      this.token = undefined;
+      while (1) {
+        const char = this.code[this.i];
+        if (char === '\n') {
+          needIndent = true;
+          skipFragment += char;
+          this.next();
+          continue;
+        }
+        if (!needIndent) {
+          skipFragment += char;
+          this.next();
+          continue;
+        }
+        needIndent = false;
+        const _this$getDentValue = this.getDentValue(),
+          value = _this$getDentValue.value,
+          isEmptyLine = _this$getDentValue.isEmptyLine;
+        const currLen = value.length;
+        if (isEmptyLine) continue;
+        if (currLen > logicDentLen) {
+          skipFragment += value;
         } else {
-          end = mid;
+          for (let i = this.dentStack.length - 1; i >= 0; i--) {
+            const expLen = this.dentStack[i];
+            if (currLen === expLen) break;
+            if (currLen > expLen) {
+              throw SyntaxError(`缩进错误，缩进长度不匹配`);
+            }
+            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),
+                loc: null
+              });
+            }
+          }
+          break;
         }
       }
-      candyLast[end] = i;
-      toPrev[i] = candyLast[start];
-      i++;
+      if (!this.token) {
+        this.nextToken();
+      }
+      return skipFragment;
     }
-    let length = candyLast.length;
-    for (let j = length - 1; j > 0; j--) {
-      const prev = toPrev[candyLast[j]];
-      candyLast[j - 1] = prev;
+    setCode(code) {
+      this.code = '\n' + code.trimEnd() + `\n${Tokenizer.EofId}`;
     }
-    return candyLast;
-  }
-
-  const KEY_INDEX = '__BOBE_KEY_INDEX';
-
-  const _excluded = ["dentStack", "isFirstToken"];
-  class Interpreter {
-    constructor(tokenizer) {
-      this.tokenizer = tokenizer;
+    tokenize() {
+      do {
+        this.nextToken();
+        console.log('token:', TokenType[this.token?.type], JSON.stringify(this.token?.value || ''));
+      } while (!this.isEof());
     }
-    isLogicNode(node) {
-      return node && node.__logicType & LogicalBit;
+    isEof() {
+      if (!this.token) return false;
+      return this.token.type & TokenType.Identifier && this.token.value === Tokenizer.EofId;
     }
-    rootComponent = null;
-    program(root, componentNode, before, ctxProvider) {
-      this.rootComponent = componentNode;
-      this.tokenizer.nextToken();
-      const stack = new MultiTypeStack();
-      stack.push({
-        node: root,
-        prev: null
-      }, NodeSort.Real);
-      stack.push({
-        node: componentNode,
-        prev: null
-      }, NodeSort.Component | NodeSort.CtxProvider | NodeSort.TokenizerSwitcher);
-      if (ctxProvider) {
-        stack.push({
-          node: ctxProvider,
-          prev: null
-        }, (ctxProvider.__logicType & LogicalBit ? NodeSort.Logic : 0) | NodeSort.CtxProvider);
-      }
-      const rootLen = stack.length;
-      const ctx = this.ctx = {
-        realParent: root,
-        prevSibling: before,
-        current: null,
-        stack,
-        before
+    setToken(type, value) {
+      this.token = {
+        type,
+        typeName: TokenType[type],
+        value,
+        loc: null
       };
-      const rootPulling = aoye.getPulling();
-      while (1) {
-        if (this.tokenizer.isEof()) {
-          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.nextToken();
-          const isLogicNode = this.isLogicNode(ctx.current);
-          stack.push({
-            node: ctx.current,
-            prev: ctx.prevSibling
-          }, !ctx.current.__logicType ? NodeSort.Real : (ctx.current.__logicType & LogicalBit ? NodeSort.Logic : 0) | (ctx.current.__logicType & TokenizerSwitcherBit ? NodeSort.TokenizerSwitcher : 0) | (ctx.current.__logicType === FakeType.Component ? NodeSort.Component : 0) | NodeSort.CtxProvider);
-          if (ctx.current.__logicType) {
-            if (isLogicNode) {
-              aoye.setPulling(ctx.current.effect);
-              if (ctx.current.__logicType & FakeType.ForItem) {
-                ctx.prevSibling = ctx.current.realBefore;
-              }
-            }
-          } else {
-            if (ctx.current) {
-              ctx.realParent = ctx.current;
-            }
-            ctx.prevSibling = null;
-          }
-          ctx.current = this.declaration(ctx);
-          continue;
+      this.isFirstToken = false;
+    }
+    nextToken() {
+      try {
+        if (this.isEof()) {
+          return this.token;
         }
-        if (ctx.current) {
-          if (stack.length === rootLen && !ctx.prevSibling) {
-            ctx.prevSibling = before;
-          }
-          this.handleInsert(ctx.realParent, ctx.current, ctx.prevSibling);
+        this.token = undefined;
+        if (this.waitingTokens.len) {
+          const item = this.waitingTokens.shift();
+          this.setToken(item.type, item.value);
+          return this.token;
         }
-        if (this.tokenizer.token.type & TokenType.Dedent) {
-          this.tokenizer.nextToken();
-          const _stack$pop = stack.pop(),
-            _stack$pop2 = _slicedToArray(_stack$pop, 2),
-            _stack$pop2$ = _stack$pop2[0],
-            parent = _stack$pop2$.node,
-            prev = _stack$pop2$.prev,
-            sort = _stack$pop2[1];
-          if (!parent.__logicType) {
-            const prevSameType = stack.peekByType(NodeSort.Real);
-            ctx.realParent = prevSameType?.node || root;
+        outer: while (1) {
+          if (this.needIndent) {
+            this.dent();
           } else {
-            if (sort & NodeSort.Logic) {
-              const parentLogic = stack.peekByType(NodeSort.Logic)?.node;
-              if (parentLogic) {
-                aoye.setPulling(parentLogic.effect);
-              } else {
-                aoye.setPulling(rootPulling);
-              }
-            }
-            if (sort & NodeSort.TokenizerSwitcher) {
-              const switcher = stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
-              this.tokenizer = switcher.tokenizer;
-            }
-            if (parent.__logicType === FakeType.ForItem) {
-              const _ref = parent,
-                forNode = _ref.forNode;
-              const i = forNode.i,
-                arr = forNode.arr,
-                snapshot = forNode.snapshot;
-              if (i + 1 < arr.length) {
-                this.tokenizer.resume(snapshot);
-                this.tokenizer.nextToken();
-                this.tokenizer.nextToken();
-                ctx.current = forNode.children[++forNode.i];
-                ctx.prevSibling = ctx.current.realBefore;
-                continue;
-              }
-              ctx.prevSibling = forNode.prevSibling;
-              ctx.current = forNode;
-              continue;
+            const char = this.code[this.i];
+            switch (char) {
+              case '\t':
+              case ' ':
+                break;
+              case '\n':
+                this.newLine();
+                this.needIndent = true;
+                break;
+              case '=':
+                this.assignment();
+                break;
+              case '|':
+                this.pipe();
+                break;
+              case ';':
+                this.setToken(TokenType.Semicolon, ';');
+                break;
+              default:
+                if (false) ;
+                switch (char) {
+                  case "'":
+                  case '"':
+                    this.str(char);
+                    break;
+                  case '{':
+                    const braceToken = this.brace();
+                    this.setToken(TokenType.InsertionExp, braceToken);
+                    break;
+                  case '$':
+                    const handled = this.staticIns();
+                    if (handled) break;
+                  default:
+                    if (bobeShared.isNum(char)) {
+                      this.number(char);
+                      break;
+                    }
+                    if (typeof char === 'string' && bobeShared.matchIdStart2(char, 0)) {
+                      this.identifier(char);
+                    }
+                    break;
+                }
+                if (false) ;
+                break;
             }
+            this.next();
+          }
+          if (this.token) {
+            break;
           }
-          ctx.prevSibling = prev;
-          ctx.current = parent;
-        } else {
-          ctx.prevSibling = ctx.current || ctx.prevSibling;
-          ctx.current = this.declaration(ctx);
         }
+        return this.token;
+      } catch (error) {
+        console.error(error);
+        return this.token;
+      } finally {
+        this.handledTokens.push(this.token);
       }
-      return componentNode;
-    }
-    insertAfterAnchor(name = 'anchor') {
-      const _this$ctx = this.ctx,
-        realParent = _this$ctx.realParent,
-        prevSibling = _this$ctx.prevSibling,
-        stack = _this$ctx.stack,
-        before = _this$ctx.before;
-      const afterAnchor = this.createAnchor(name);
-      this.ctx.prevSibling = stack.length === 2 && !prevSibling ? before : prevSibling;
-      this.handleInsert(realParent, afterAnchor, prevSibling);
-      return afterAnchor;
     }
-    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);
+    condExp() {
+      let value = '';
+      this.token = null;
+      try {
+        if (this.code[this.i] === '\n') {
+          this.setToken(TokenType.Identifier, true);
+          return this.token;
         }
-      } else {
-        const childCmp = child;
-        childCmp.realParent = parent;
-        if (prev?.__logicType) {
-          childCmp.realBefore = prev.forNode ? prev.forNode.realAfter : prev.realAfter;
-        } else {
-          childCmp.realBefore = prev;
+        while (this.code[this.i + 1] !== '\n') {
+          value += this.code[this.i];
+          this.next();
         }
+        value += this.code[this.i];
+        const trimmed = value.trim();
+        this.setToken(TokenType.Identifier, trimmed ? value : true);
+        return this.token;
+      } finally {
+        this.next();
+        this.handledTokens.push(this.token);
       }
     }
-    getPrevRealSibling(prevSibling) {
-      if (!prevSibling || !prevSibling.__logicType) {
-        return prevSibling;
-      }
-      let point = prevSibling;
-      while (point != null) {
-        if (point.lastChild) {
-          return point.lastChild.value;
+    jsExp() {
+      this.token = null;
+      let value = '';
+      try {
+        const char = this.code[this.i];
+        if (char === ';' || char === '\n') {
+          this.setToken(TokenType.Identifier, value);
+          return this.token;
         }
-        point = point.anchor;
-      }
-    }
-    declaration(ctx) {
-      const _this$tokenizer$_hook = this.tokenizer._hook({}),
-        _this$tokenizer$_hook2 = _slicedToArray(_this$tokenizer$_hook, 2),
-        hookType = _this$tokenizer$_hook2[0],
-        value = _this$tokenizer$_hook2[1];
-      let _node;
-      if (value === 'if' || value === 'else' || value === 'fail') {
-        return this.condDeclaration(ctx);
-      } else if (value === 'for') {
-        return this.forDeclaration();
-      } else if (hookType) {
-        const data = this.getData();
-        if (hookType === 'static') {
-          if (typeof value === 'function') {
-            _node = this.componentOrFragmentDeclaration(value, ctx);
-          } else {
-            throw new SyntaxError(`declaration 不支持 ${value} 类型的静态插值`);
-          }
-        } else {
-          const valueIsMapKey = Reflect.has(data[aoye.Keys.Raw], value);
-          const val = data[aoye.Keys.Raw][value];
-          if (typeof val === 'function') {
-            _node = this.componentOrFragmentDeclaration(val, ctx);
-          } else {
-            const str = valueIsMapKey ? value : this.getFn(data, value);
-            _node = this.createNode('text');
-            this.onePropParsed(data, _node, 'text', str, valueIsMapKey, false);
-          }
+        let nextC = this.code[this.i + 1];
+        while (nextC !== ';' && nextC !== '\n') {
+          value += this.code[this.i];
+          this.next();
+          nextC = this.code[this.i + 1];
         }
-      } else {
-        _node = this.createNode(value);
+        value += this.code[this.i];
+        this.setToken(TokenType.Identifier, value);
+        return this.token;
+      } finally {
+        this.next();
+        this.handledTokens.push(this.token);
       }
-      this.tokenizer.nextToken();
-      this.headerLine(_node);
-      this.extensionLines(_node);
-      if (_node.__logicType & TokenizerSwitcherBit) {
-        this.onePropParsed = this.oneRealPropParsed;
-        this.tokenizer = _node.tokenizer;
+    }
+    peekChar() {
+      let i = this.i;
+      while (this.code[i] === ' ' || this.code[i] === '\t') {
+        i++;
       }
-      return _node;
+      return this.code[i];
     }
-    forDeclaration() {
-      const arrExp = this.tokenizer.nextToken().value;
-      this.tokenizer.nextToken();
-      const itemToken = this.tokenizer.nextToken();
-      const isDestruct = itemToken.type === TokenType.InsertionExp;
-      let itemExp = itemToken.value,
-        vars;
-      if (isDestruct) {
-        itemExp = '{' + itemExp + '}';
-        vars = itemExp.match(bobeShared.jsVarRegexp);
-        const varStr = vars.join(',');
-        itemExp = new Function(itemExp, `return {${varStr}};`);
+    assignment() {
+      this.setToken(TokenType.Assign, '=');
+    }
+    pipe() {
+      this.setToken(TokenType.Pipe, '|');
+    }
+    staticIns() {
+      let nextC = this.code[this.i + 1];
+      if (nextC !== '{') {
+        return false;
       }
-      let indexName,
-        keyExp,
-        char = this.tokenizer.peekChar();
-      if (char === ';') {
-        this.tokenizer.nextToken();
-        if (this.tokenizer.peekChar() !== '\n') keyExp = this.tokenizer.jsExp().value;
-      } else if (char === '\n') ; else {
-        indexName = this.tokenizer.nextToken().value;
-        if (this.tokenizer.peekChar() === ';') {
-          this.tokenizer.nextToken();
-          if (this.tokenizer.peekChar() !== '\n') keyExp = this.tokenizer.jsExp().value;
+      this.next();
+      let value = '';
+      let innerBrace = 0;
+      while (1) {
+        nextC = this.code[this.i + 1];
+        value += nextC;
+        this.next();
+        if (nextC === '{') {
+          innerBrace++;
+        }
+        if (nextC === '}') {
+          if (!innerBrace) {
+            break;
+          }
+          innerBrace--;
         }
       }
-      const owner = this.ctx.stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
-      const prevSibling = this.ctx.prevSibling;
-      const forNode = {
-        __logicType: FakeType.For,
-        snapshot: this.tokenizer.snapshot(['dentStack', 'isFirstToken']),
-        realParent: this.ctx.realParent,
-        prevSibling,
-        realBefore: prevSibling?.realAfter || prevSibling,
-        realAfter: null,
-        arr: null,
-        arrSignal: null,
-        itemExp,
-        indexName,
-        getKey: null,
-        children: [],
-        effect: null,
-        owner,
-        vars,
-        i: 0
+      this.setToken(TokenType.StaticInsExp, value.slice(0, -1));
+      return true;
+    }
+    brace() {
+      let inComment,
+        inString,
+        count = 0,
+        value = '',
+        backslashCount = 0;
+      while (1) {
+        const char = this.code[this.i];
+        const nextChar = this.code[this.i + 1];
+        if (inComment === 'single' && char === '\n') {
+          inComment = null;
+        } else if (inComment === 'multi' && char === '*' && nextChar === '/') {
+          inComment = null;
+          value += this.code[this.i];
+          this.next();
+        } else if (inString) {
+          if (char === inString && backslashCount % 2 === 0) {
+            inString = null;
+          }
+          backslashCount = char === '\\' ? backslashCount + 1 : 0;
+        } else {
+          if (char === '/' && nextChar === '/') {
+            inComment = 'single';
+            value += this.code[this.i];
+            this.next();
+          } else if (char === '/' && nextChar === '*') {
+            inComment = 'multi';
+            value += this.code[this.i];
+            this.next();
+          } else if (char === "'" || char === '"' || char === '`') {
+            inString = char;
+          } else if (char === '{') {
+            count++;
+          } else if (char === '}') {
+            count--;
+          }
+        }
+        if (count === 0 && inString == null && inComment == null) {
+          return value.slice(1);
+        }
+        value += this.code[this.i];
+        this.next();
+      }
+    }
+    newLine() {
+      let value = '\n';
+      let nextC;
+      while (1) {
+        nextC = this.code[this.i + 1];
+        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.code[this.i];
+        switch (nextChar) {
+          case '\t':
+            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
       };
-      if (keyExp) {
-        forNode.getKey = new Function('data', `let v;with(data){v=${keyExp}};return v;`);
+    }
+    dent() {
+      const _this$getDentValue2 = this.getDentValue(),
+        value = _this$getDentValue2.value,
+        isEmptyLine = _this$getDentValue2.isEmptyLine;
+      if (isEmptyLine) {
+        this.needIndent = true;
+        return;
       }
-      window['for1'] = forNode;
-      const data = this.getData();
-      const cells = data[aoye.Keys.Meta].cells;
-      const hasArrExpKey = Reflect.has(data[aoye.Keys.Raw], arrExp);
-      const arrSignal = hasArrExpKey ? (data[arrExp], cells.get(arrExp)) : new aoye.Computed(this.getFn(data, arrExp));
-      forNode.arrSignal = arrSignal;
-      forNode.realAfter = this.insertAfterAnchor('for-after');
-      const _forNode$snapshot = forNode.snapshot;
-        _forNode$snapshot.dentStack;
-        _forNode$snapshot.isFirstToken;
-        const snapshotForUpdate = _objectWithoutProperties(_forNode$snapshot, _excluded);
-      let isFirstRender = true;
-      forNode.effect = new aoye.Effect(() => {
-        let arr = arrSignal.get();
-        arr[aoye.Keys.Iterator];
-        const prevCtx = aoye.getPulling();
-        aoye.setPulling(null);
-        forNode.arr = arr = aoye.toRaw(arr);
-        const children = forNode.children;
-        if (isFirstRender) {
-          const len = arr.length;
-          for (let i = len; i--;) {
-            const item = this.createForItem(forNode, i, data);
-            item.realAfter = this.insertAfterAnchor('for-item-after');
-            item.realBefore = this.insertAfterAnchor('for-item-before');
-            item.realParent = forNode.realParent;
-            children[i] = item;
+      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, 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('缩进大小不统一');
           }
-          const firstInsert = children[0];
-          if (firstInsert) {
-            this.tokenizer.nextToken();
-            this.tokenizer.nextToken();
-          } else {
-            this.tokenizer.skip();
+          if (this.shorterThanBaseDentEof()) {
+            return;
           }
-        } else {
-          const oldLen = children.length;
-          const newLen = arr.length;
-          const minLen = Math.min(oldLen, newLen);
-          const newChildren = [];
-          if (!forNode.getKey) {
-            if (newLen < oldLen) {
-              for (let i = oldLen - 1; i >= newLen; i--) {
-                this.removeForItem(children, i);
-              }
-            }
-            if (oldLen < newLen) {
-              const lastAfter = children.at(-1)?.realAfter || forNode.realBefore;
-              for (let i = newLen - 1; i >= oldLen; i--) {
-                this.insertForItem(forNode, i, data, newChildren, lastAfter, snapshotForUpdate);
-              }
-            }
-            for (let i = minLen; i--;) {
-              const child = children[i];
-              newChildren[i] = child;
-              this.reuseForItem(child, arr[i], itemExp, i, indexName);
-            }
+          this.dentStack.pop();
+          if (!this.token) {
+            this.setToken(TokenType.Dedent, String(expLen));
           } else {
-            let s = 0,
-              e1 = oldLen - 1,
-              e2 = newLen - 1;
-            while (s <= e1 && s <= e2) {
-              const child = children[s];
-              const old = child.key;
-              const itemData = this.getItemData(forNode, s, data);
-              const key = forNode.getKey(itemData);
-              if (old === key) {
-                newChildren[s] = child;
-                this.reuseForItem(child, arr[s], itemExp, s, indexName);
-                s++;
-              } else {
-                break;
-              }
-            }
-            while (s <= e1 && s <= e2) {
-              const child = children[e1];
-              const old = child.key;
-              const itemData = this.getItemData(forNode, e2, data);
-              const key = forNode.getKey(itemData);
-              if (old === key) {
-                newChildren[e2] = child;
-                this.reuseForItem(child, arr[e2], itemExp, e2, indexName);
-                e1--;
-                e2--;
-              } else {
-                break;
-              }
-            }
-            if (s > e1) {
-              if (s <= e2) {
-                const firstBefore = s > 0 ? children.at(-1)?.realAfter || forNode.realBefore : forNode.realBefore;
-                for (let i = e2; i >= s; i--) {
-                  this.insertForItem(forNode, i, data, newChildren, firstBefore, snapshotForUpdate);
-                }
-              }
-            } else if (s > e2) {
-              if (s <= e1) {
-                for (let i = e1; i >= s; i--) {
-                  this.removeForItem(children, i);
-                }
-              }
-            } else {
-              let s1 = s,
-                s2 = s;
-              const mixLen = e2 - s2 + 1;
-              const key2new = new Map();
-              for (let i = s2; i <= e2; i++) {
-                const itemData = this.getItemData(forNode, i, data);
-                const key = forNode.getKey(itemData);
-                key2new.set(key, i);
-              }
-              let maxIncNewI = -1;
-              let hasMove = false;
-              const new2oldI = new Array(mixLen).fill(-1);
-              for (let i = s1; i <= e1; i++) {
-                const key = children[i].key;
-                const newI = key2new.get(key);
-                if (newI == null) {
-                  this.removeForItem(children, i);
-                  continue;
-                }
-                const child = children[i];
-                newChildren[newI] = child;
-                this.reuseForItem(child, arr[newI], itemExp, newI, indexName);
-                new2oldI[newI - s2] = i;
-                key2new.delete(key);
-                if (newI < maxIncNewI) {
-                  hasMove = true;
-                } else {
-                  maxIncNewI = newI;
-                }
-              }
-              if (!hasMove) {
-                key2new.forEach((i, key) => {
-                  const before = i === 0 ? forNode.realBefore : newChildren[i - 1].realAfter;
-                  this.insertForItem(forNode, i, data, newChildren, before, snapshotForUpdate);
-                });
-              } else {
-                const incI = macInc(new2oldI),
-                  incLen = incI.length;
-                let p1, p2;
-                for (p1 = s2, p2 = 0; p1 <= e2; p1++) {
-                  const oldI = new2oldI[p1];
-                  if (oldI === -1) {
-                    const before = p1 === 0 ? forNode.realBefore : newChildren[p1 - 1].realAfter;
-                    this.insertForItem(forNode, p1, data, newChildren, before, snapshotForUpdate);
-                    continue;
-                  }
-                  const staticIdx = incI[p2] + s2;
-                  if (p1 === staticIdx) {
-                    p2 <= incLen && p2++;
-                    continue;
-                  }
-                  let before = p1 === 0 ? forNode.realBefore : newChildren[p1 - 1].realAfter;
-                  const child = newChildren[p1];
-                  const realBefore = child.realBefore,
-                    realAfter = child.realAfter,
-                    realParent = child.realParent;
-                  let point = realBefore,
-                    next;
-                  do {
-                    next = this.nextSib(point);
-                    this.insertAfter(realParent, point, before);
-                    before = point;
-                    if (point === realAfter) break;
-                    point = next;
-                  } while (true);
-                }
-              }
-            }
+            this.waitingTokens.push({
+              type: TokenType.Dedent,
+              typeName: TokenType[TokenType.Dedent],
+              value: String(expLen),
+              loc: null
+            });
           }
-          forNode.children = newChildren;
         }
-        isFirstRender = false;
-        aoye.setPulling(prevCtx);
-        return isDestroy => {
-          if (isDestroy) {
-            for (let i = 0; i < forNode.children.length; i++) {
-              const item = forNode.children[i];
-              item.effect.dispose();
-            }
+        return indentHasLen;
+      }
+      return indentHasLen;
+    }
+    shorterThanBaseDentEof() {
+      const yes = this.dentStack.length === 1;
+      if (yes) {
+        if (!this.token) {
+          if (this.useDedentAsEof) {
+            this.setToken(TokenType.Dedent, '');
+          } else {
+            this.setToken(TokenType.Identifier, Tokenizer.EofId);
           }
-        };
-      });
-      return forNode.children[0] || forNode;
+        } else {
+          if (this.useDedentAsEof) {
+            this.waitingTokens.push({
+              type: TokenType.Dedent,
+              typeName: TokenType[TokenType.Dedent],
+              value: '',
+              loc: null
+            });
+          } else {
+            this.waitingTokens.push({
+              type: TokenType.Identifier,
+              typeName: TokenType[TokenType.Identifier],
+              value: Tokenizer.EofId,
+              loc: null
+            });
+          }
+        }
+      }
+      return yes;
     }
-    insertForItem(forNode, i, parentData, newChildren, before, snapshotForUpdate) {
-      const item = this.createForItem(forNode, i, parentData);
-      newChildren[i] = item;
-      let realAfter = this.createAnchor('for-item-after');
-      this.handleInsert(forNode.realParent, realAfter, before);
-      let realBefore = this.createAnchor('for-item-before');
-      this.handleInsert(forNode.realParent, realBefore, before);
-      item.realBefore = realBefore;
-      item.realAfter = realAfter;
-      this.tokenizer = forNode.owner.tokenizer;
-      this.tokenizer.resume(snapshotForUpdate);
-      this.tokenizer.useDedentAsEof = false;
-      aoye.runWithPulling(() => {
-        this.program(forNode.realParent, forNode.owner, realBefore, item);
-      }, item.effect);
+    identifier(char) {
+      let value = char;
+      let nextC;
+      while (1) {
+        nextC = this.code[this.i + 1];
+        if (typeof nextC !== 'string' || !bobeShared.matchIdStart2(nextC, 0)) {
+          break;
+        }
+        value += nextC;
+        this.next();
+      }
+      if (value === Tokenizer.EofId && this.useDedentAsEof) {
+        this.setToken(TokenType.Dedent, '');
+        return;
+      }
+      let realValue = value === 'null' ? null : value === 'undefined' ? undefined : value === 'false' ? false : value === 'true' ? true : value;
+      this.setToken(TokenType.Identifier, realValue);
     }
-    removeForItem(children, i) {
-      const child = children[i];
-      this.removeLogicNode(child);
-      this.remove(child.realBefore);
-      this.remove(child.realAfter);
-      child.effect.dispose();
+    str(char) {
+      let value = '';
+      let nextC;
+      let continuousBackslashCount = 0;
+      while (1) {
+        nextC = this.code[this.i + 1];
+        const memoCount = continuousBackslashCount;
+        if (nextC === '\\') {
+          continuousBackslashCount++;
+        } else {
+          continuousBackslashCount = 0;
+        }
+        this.next();
+        if (nextC === char && memoCount % 2 === 0) {
+          break;
+        }
+        value += nextC;
+      }
+      this.setToken(TokenType.Identifier, value);
     }
-    reuseForItem(child, data, itemExp, i, indexName) {
-      if (typeof itemExp === 'string') {
-        child.data[itemExp] = data;
-        if (indexName) {
-          child.data[indexName] = i;
+    number(char) {
+      let value = char;
+      let nextC;
+      while (1) {
+        nextC = this.code[this.i + 1];
+        if (!bobeShared.isNum(nextC)) {
+          break;
         }
+        value += nextC;
+        this.next();
+      }
+      this.setToken(TokenType.Identifier, Number(value));
+    }
+    eof() {
+      this.setToken(TokenType.Eof, 'End Of File');
+    }
+    HookId = '_h_o_o_k_';
+    hookI = 0;
+    _hook = props => {
+      const value = this.token.value;
+      const isDynamicHook = this.token.type & TokenType.InsertionExp;
+      let isStaticHook;
+      {
+        isStaticHook = typeof value === 'string' && value.indexOf(this.HookId) === 0;
+      }
+      const hookType = isDynamicHook ? 'dynamic' : isStaticHook ? 'static' : undefined;
+      if (this.hook && isStaticHook) {
+        const hookI = Number(value.slice(this.HookId.length));
+        const res = this.hook({
+          ...props,
+          HookId: this.HookId,
+          i: hookI
+        });
+        return [hookType, res, hookI];
+      } else if (isDynamicHook) {
+        return [hookType, value];
+      }
+      return [hookType, value];
+    };
+    init(fragments) {
+      if (typeof fragments === 'string') {
+        this.setCode(fragments);
       } else {
-        indexName = indexName || KEY_INDEX;
-        child.data[indexName] = i;
+        let code = '';
+        for (let i = 0; i < fragments.length - 1; i++) {
+          const fragment = fragments[i];
+          code += fragment + `${this.HookId}${i}`;
+        }
+        this.setCode(code + fragments[fragments.length - 1]);
       }
     }
-    forItemId = 0;
-    createForItem(forNode, i, parentData) {
-      let forItemNode;
-      let data;
-      const scope = new aoye.Scope(() => {});
-      scope.scope = null;
-      aoye.runWithPulling(() => {
-        scope.get();
-      }, null);
-      data = this.getItemData(forNode, i, parentData);
-      forItemNode = {
-        id: this.forItemId++,
-        __logicType: FakeType.ForItem,
-        realParent: null,
-        realBefore: null,
-        realAfter: null,
-        forNode,
-        key: forNode.getKey?.(data),
-        effect: null,
-        data
+  }
+
+  var NodeType = function (NodeType) {
+    NodeType["Element"] = "Element";
+    NodeType["Text"] = "Text";
+    NodeType["Interpolation"] = "Interpolation";
+    NodeType["Property"] = "Property";
+    NodeType["PropertyKey"] = "PropertyKey";
+    NodeType["StaticValue"] = "StaticValue";
+    NodeType["DynamicValue"] = "DynamicValue";
+    NodeType["Program"] = "Program";
+    NodeType["If"] = "If";
+    NodeType["Else"] = "Else";
+    NodeType["Fail"] = "Fail";
+    NodeType["For"] = "For";
+    NodeType["Component"] = "Component";
+    NodeType["Fragment"] = "Fragment";
+    return NodeType;
+  }(NodeType || {});
+
+  function _applyDecs2311(e, t, n, r, o, i) {
+    var a,
+      c,
+      u,
+      s,
+      f,
+      l,
+      p,
+      d = Symbol.metadata || Symbol.for("Symbol.metadata"),
+      m = Object.defineProperty,
+      h = Object.create,
+      y = [h(null), h(null)],
+      v = t.length;
+    function g(t, n, r) {
+      return function (o, i) {
+        n && (i = o, o = e);
+        for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []);
+        return r ? i : o;
       };
-      forItemNode.effect = scope;
-      return forItemNode;
     }
-    getItemData(forNode, i, parentData) {
-      const arr = forNode.arr,
-        itemExp = forNode.itemExp,
-        vars = forNode.vars,
-        arrSignal = forNode.arrSignal,
-        getKey = forNode.getKey;
-      let indexName = forNode.indexName;
-      let data;
-      if (typeof itemExp === 'string') {
-        data = aoye.deepSignal(indexName ? {
-          [itemExp]: arr[i],
-          [indexName]: i
-        } : {
-          [itemExp]: arr[i]
-        }, aoye.getPulling());
-      } else {
-        indexName = indexName ?? KEY_INDEX;
-        const rawData = {
-          [indexName]: i
+    function b(e, t, n, r) {
+      if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined"));
+      return e;
+    }
+    function applyDec(e, t, n, r, o, i, u, s, f, l, p) {
+      function d(e) {
+        if (!p(e)) throw new TypeError("Attempted to access private element on non-instance");
+      }
+      var h = [].concat(t[0]),
+        v = t[3],
+        w = !u,
+        D = 1 === o,
+        S = 3 === o,
+        j = 4 === o,
+        E = 2 === o;
+      function I(t, n, r) {
+        return function (o, i) {
+          return n && (i = o, o = e), r && r(o), P[t].call(o, i);
         };
-        data = aoye.deepSignal(rawData, aoye.getPulling());
-        const computedData = new aoye.Computed(() => itemExp(arrSignal.get()[getKey ? data[indexName] : i]));
-        const cells = data[aoye.Keys.Meta].cells;
-        for (let i = 0; i < vars.length; i++) {
-          const name = vars[i];
-          rawData[name] = undefined;
-          cells.set(name, new aoye.Computed(() => computedData.get()[name]));
+      }
+      if (!w) {
+        var P = {},
+          k = [],
+          F = S ? "get" : j || D ? "set" : "value";
+        if (f ? (l || D ? P = {
+          get: _setFunctionName(function () {
+            return v(this);
+          }, r, "get"),
+          set: function (e) {
+            t[4](this, e);
+          }
+        } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) {
+          if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet");
+          y[+s][r] = o < 3 ? 1 : o;
         }
       }
-      Object.setPrototypeOf(data, parentData);
-      return data;
+      for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) {
+        var T = b(h[O], "A decorator", "be", true),
+          z = n ? h[O - 1] : void 0,
+          A = {},
+          H = {
+            kind: ["field", "accessor", "method", "getter", "setter", "class"][o],
+            name: r,
+            metadata: a,
+            addInitializer: function (e, t) {
+              if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+              b(t, "An initializer", "be", true), i.push(t);
+            }.bind(null, A)
+          };
+        if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = {
+          has: f ? p.bind() : function (e) {
+            return r in e;
+          }
+        }, j || (c.get = f ? E ? function (e) {
+          return d(e), P.value;
+        } : I("get", 0, d) : function (e) {
+          return e[r];
+        }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) {
+          e[r] = t;
+        }), N = T.call(z, D ? {
+          get: P.get,
+          set: P.set
+        } : P[F], H), A.v = 1, D) {
+          if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+        } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N);
+      }
+      return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N;
     }
-    getData() {
-      const _this$ctx$stack$peekB = this.ctx.stack.peekByType(NodeSort.CtxProvider),
-        node = _this$ctx$stack$peekB.node;
-      return node.data;
+    function w(e) {
+      return m(e, d, {
+        configurable: true,
+        enumerable: true,
+        value: a
+      });
     }
-    onePropParsed(data, node, key, value, valueIsMapKey, isFn, hookI) {
-      if (isFn) {
-        this.setProp(node, key, value, hookI);
-      } else if (typeof value === 'function') {
-        new aoye.Effect(() => {
-          const res = value();
-          this.setProp(node, key, res, hookI);
-        });
-      } else if (valueIsMapKey) {
-        new aoye.Effect(() => {
-          const res = data[value];
-          this.setProp(node, key, res, hookI);
-        });
-      } else {
-        this.setProp(node, key, value, hookI);
+    return a = h(null == a ? null : a), f = [], l = function (e) {
+      e && f.push(g(e));
+    }, p = function (t, r) {
+      for (var i = 0; i < n.length; i++) {
+        var a = n[i],
+          c = a[1],
+          l = 7 & c;
+        if ((8 & c) == t && !l == r) {
+          var p = a[2],
+            d = !!a[3],
+            m = 16 & c;
+          applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) {
+            return _checkInRHS(t) === e;
+          } : o);
+        }
+      }
+    }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), {
+      e: c,
+      get c() {
+        var n = [];
+        return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)];
+      }
+    };
+  }
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
+  }
+  function _checkInRHS(e) {
+    if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null"));
+    return e;
+  }
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = true,
+        o = false;
+      try {
+        if (i = (t = t.call(r)).next, 0 === l) {
+          if (Object(t) !== t) return;
+          f = !1;
+        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = true, n = r;
+      } finally {
+        try {
+          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
+        }
       }
+      return a;
+    }
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _objectWithoutProperties(e, t) {
+    if (null == e) return {};
+    var o,
+      r,
+      i = _objectWithoutPropertiesLoose(e, t);
+    if (Object.getOwnPropertySymbols) {
+      var n = Object.getOwnPropertySymbols(e);
+      for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+    }
+    return i;
+  }
+  function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t = {};
+    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+      if (-1 !== e.indexOf(n)) continue;
+      t[n] = r[n];
+    }
+    return t;
+  }
+  function _setFunctionName(e, t, n) {
+    "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : "");
+    try {
+      Object.defineProperty(e, "name", {
+        configurable: !0,
+        value: n ? n + " " + t : t
+      });
+    } catch (e) {}
+    return e;
+  }
+  function _slicedToArray(r, e) {
+    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r);
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
+  }
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
     }
-    oneRealPropParsed = this.onePropParsed.bind(this);
-    componentOrFragmentDeclaration(ComponentOrRender, ctx) {
-      let Component, render, child;
-      const isCC = ComponentOrRender.prototype instanceof aoye.Store;
-      if (isCC) {
-        Component = ComponentOrRender;
-        child = Component.new();
-      } else {
-        render = ComponentOrRender;
-        const boundStore = render.boundStore;
-        child = aoye.deepSignal({}, aoye.getPulling(), true);
-        Object.setPrototypeOf(child, boundStore);
+  }
+
+  let _initProto;
+  class Compiler {
+    static {
+      var _applyDecs$e = _slicedToArray(_applyDecs2311(this, [], [[NodeHook, 2, "parseProgram"], [[NodeHook, NodeLoc], 2, "parseComponentNode"], [[NodeHook, NodeLoc], 2, "parseElementNode"], [[NodeHook, NodeLoc], 2, "parseConditionalNode"], [[NodeHook, NodeLoc], 2, "parseLoopNode"], [NodeHook, 2, "parseProperty"], [[NodeHook, TokenLoc], 2, "parsePropertyKey"], [[NodeHook, TokenLoc], 2, "parsePropertyValue"]]).e, 1);
+      _initProto = _applyDecs$e[0];
+    }
+    constructor(tokenizer, hooks = {}) {
+      this.tokenizer = tokenizer;
+      this.hooks = hooks;
+      _initProto(this);
+    }
+    parseProgram() {
+      this.tokenizer.nextToken();
+      const body = [];
+      while (!this.tokenizer.isEof()) {
+        const node = this.templateNode();
+        if (node) {
+          body.push(node);
+        }
       }
-      const node = {
-        __logicType: isCC ? FakeType.Component : FakeType.Fragment,
-        realParent: ctx.realParent,
-        realBefore: null,
-        realAfter: null,
-        data: child,
-        tokenizer: render ? render(true) : child['ui'](true)
-      };
-      this.onePropParsed = (data, _, key, value, valueIsMapKey, isFn, hookI) => {
-        if (isFn) {
-          child[aoye.Keys.Raw][key] = value;
-        } else if (valueIsMapKey) {
-          aoye.shareSignal(data, value, child, key);
-        } else {
-          const meta = child[aoye.Keys.Meta];
-          const cells = meta.cells;
-          if (typeof value === 'function') {
-            const computed = new aoye.Computed(value);
-            cells.set(key, computed);
-            child[aoye.Keys.Raw][key] = undefined;
-          } else {
-            cells.set(key, {
-              get: () => value
-            });
-            child[aoye.Keys.Raw][key] = value;
-          }
+      return {
+        type: NodeType.Program,
+        body,
+        loc: {
+          start: {
+            offset: 0,
+            line: 1,
+            column: 0
+          },
+          end: {
+            offset: this.tokenizer.preI,
+            line: this.tokenizer.line,
+            column: this.tokenizer.column
+          },
+          source: this.tokenizer.code
         }
       };
-      node.realAfter = this.insertAfterAnchor('component-after');
-      return node;
     }
-    getFn(data, expression) {
-      return new Function('data', `let v;with(data){v=${expression}};return v;`).bind(undefined, data);
-    }
-    condDeclaration(ctx) {
-      const prevSibling = ctx.prevSibling;
-      const keyWord = this.tokenizer.token;
-      const expToken = this.tokenizer.condExp();
-      const value = expToken.value;
-      const isElse = keyWord.value === 'else';
-      const isIf = keyWord.value === 'if';
-      const preIsCond = prevSibling?.__logicType & CondBit;
-      const data = this.getData();
-      const noCond = value === true;
-      const valueIsMapKey = !noCond && Reflect.has(data[aoye.Keys.Raw], value);
-      const owner = ctx.stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
-      const ifNode = {
-        __logicType: isElse ? FakeType.Else : isIf ? FakeType.If : FakeType.Fail,
-        snapshot: this.tokenizer.snapshot(),
-        realParent: null,
-        realBefore: null,
-        realAfter: null,
-        condition: null,
-        preCond: preIsCond ? prevSibling : null,
-        isFirstRender: true,
-        effect: null,
-        owner,
-        data
-      };
-      let signal;
-      switch (keyWord.value) {
-        case 'if':
-          if (valueIsMapKey) {
-            aoye.runWithPulling(() => data[value], null);
-            const cells = data[aoye.Keys.Meta].cells;
-            signal = cells.get(value);
-          } else {
-            const fn = this.getFn(data, value);
-            signal = new aoye.Computed(fn);
-          }
-          break;
-        case 'else':
-          if (noCond) {
-            signal = new aoye.Computed(() => {
-              let point = ifNode.preCond;
-              while (point) {
-                if (point.condition.get()) {
-                  return false;
-                }
-                if (point.__logicType === FakeType.If) {
-                  break;
-                }
-                point = point.preCond;
-              }
-              return true;
-            });
-          } else {
-            const fn = valueIsMapKey ? null : this.getFn(data, value);
-            signal = new aoye.Computed(() => {
-              let point = ifNode.preCond;
-              while (point) {
-                if (point.condition.get()) {
-                  return false;
-                }
-                if (point.__logicType === FakeType.If) {
-                  break;
-                }
-                point = point.preCond;
-              }
-              return valueIsMapKey ? data[value] : fn();
-            });
-          }
-          break;
-        case 'fail':
-          signal = new aoye.Computed(() => {
-            let point = ifNode.preCond;
-            while (point) {
-              if (point.condition.get()) {
-                return false;
-              }
-              point = point.preCond;
-            }
-            return true;
-          });
-          break;
-      }
-      ifNode.condition = signal;
-      ifNode.realAfter = this.insertAfterAnchor(`${keyWord.value}-after`);
-      const ef = aoye.effect(({
-        val
-      }) => {
-        if (val) {
-          if (ifNode.isFirstRender) {
-            this.tokenizer.nextToken();
-            this.tokenizer.nextToken();
-          } else {
-            this.tokenizer = ifNode.owner.tokenizer;
-            this.tokenizer.resume(ifNode.snapshot);
-            this.tokenizer.useDedentAsEof = false;
-            this.program(ifNode.realParent, ifNode.owner, ifNode.realBefore, ifNode);
-          }
-        } else {
-          if (ifNode.isFirstRender) {
-            this.tokenizer.skip();
-          } else {
-            this.removeLogicNode(ifNode);
+    handleChildren() {
+      const children = [];
+      if (this.tokenizer.token.type & TokenType.Indent) {
+        this.tokenizer.nextToken();
+        while (!(this.tokenizer.token.type & TokenType.Dedent) && !this.tokenizer.isEof()) {
+          const child = this.templateNode();
+          if (child) {
+            children.push(child);
           }
         }
-        ifNode.isFirstRender = false;
-      }, [signal]);
-      ifNode.effect = ef;
-      return ifNode;
+        if (this.tokenizer.token.type & TokenType.Dedent) {
+          this.tokenizer.nextToken();
+        }
+      }
+      return children;
     }
-    removeLogicNode(node) {
-      const realBefore = node.realBefore,
-        realAfter = node.realAfter,
-        realParent = node.realParent;
-      let point = realBefore ? this.nextSib(realBefore) : this.firstChild(realParent);
-      while (point !== realAfter) {
-        const next = this.nextSib(point);
-        this.remove(point, realParent, realBefore);
-        point = next;
+    templateNode() {
+      this.tokenizer.token;
+      const _this$tokenizer$_hook = this.tokenizer._hook({}),
+        _this$tokenizer$_hook2 = _slicedToArray(_this$tokenizer$_hook, 2),
+        hookType = _this$tokenizer$_hook2[0],
+        value = _this$tokenizer$_hook2[1];
+      if (value === 'if' || value === 'else' || value === 'fail') {
+        return this.parseConditionalNode();
       }
+      if (value === 'for') {
+        return this.parseLoopNode();
+      }
+      if (hookType) {
+        return this.parseComponentNode();
+      }
+      return this.parseElementNode();
     }
-    extensionLines(_node) {
-      while (1) {
-        if ((this.tokenizer.token.type & TokenType.Pipe) === 0) {
-          return;
-        }
+    parseComponentNode(node) {
+      const tagToken = this.tokenizer.token;
+      const tagName = tagToken.value;
+      this.tokenizer.nextToken();
+      const props = this.headerLineAndExtensions();
+      node.type = NodeType.Component;
+      node.componentName = tagName;
+      node.props = props;
+      this.hooks.parseComponentNode?.propsAdded?.call(this, node);
+      const children = this.handleChildren();
+      node.children = children;
+      return node;
+    }
+    parseElementNode(node) {
+      const tagToken = this.tokenizer.token;
+      const tagName = tagToken.value;
+      this.tokenizer.nextToken();
+      const props = this.headerLineAndExtensions();
+      node.type = NodeType.Element;
+      node.tagName = tagName;
+      node.props = props;
+      this.hooks.parseElementNode?.propsAdded?.call(this, node);
+      const children = this.handleChildren();
+      node.children = children;
+      return node;
+    }
+    parseConditionalNode(node) {
+      const keyword = this.tokenizer.token.value;
+      const conditionToken = this.tokenizer.condExp();
+      const condition = conditionToken.value;
+      this.tokenizer.nextToken();
+      this.tokenizer.nextToken();
+      node.type = keyword === 'if' ? NodeType.If : keyword === 'else' ? NodeType.Else : NodeType.Fail;
+      node.condition = condition;
+      this.hooks.parseConditionalNode?.propsAdded?.call(this, node);
+      const children = this.handleChildren();
+      node.children = children;
+      return node;
+    }
+    parseLoopNode(node) {
+      const collection = this.tokenizer.nextToken().value;
+      this.tokenizer.nextToken();
+      const itemToken = this.tokenizer.nextToken();
+      const isDestruct = itemToken.type === TokenType.InsertionExp;
+      let item = isDestruct ? `{${itemToken.value}}` : itemToken.value;
+      let char = this.tokenizer.peekChar(),
+        key,
+        index;
+      if (char === ';') {
         this.tokenizer.nextToken();
-        this.attributeList(_node);
-        if ((this.tokenizer.token.type & TokenType.NewLine) === 0) {
-          return;
+        if (this.tokenizer.peekChar() !== '\n') key = this.tokenizer.jsExp().value;
+      } else if (char === '\n') ; else {
+        index = this.tokenizer.nextToken().value;
+        if (this.tokenizer.peekChar() === ';') {
+          this.tokenizer.nextToken();
+          if (this.tokenizer.peekChar() !== '\n') key = this.tokenizer.jsExp().value;
         }
-        this.tokenizer.nextToken();
       }
-    }
-    headerLine(_node) {
-      this.attributeList(_node);
       this.tokenizer.nextToken();
+      this.tokenizer.nextToken();
+      node.type = NodeType.For;
+      node.collection = collection;
+      node.item = item;
+      node.index = index;
+      node.key = key;
+      this.hooks.parseLoopNode?.propsAdded?.call(this, node);
+      const children = this.handleChildren();
+      node.children = children;
+      return node;
     }
-    attributeList(_node) {
-      let key, eq;
-      const data = this.getData();
-      while ((this.tokenizer.token.type & TokenType.NewLine) === 0) {
-        if (key == null) {
-          key = this.tokenizer.token.value;
-        } else if (eq == null) {
-          eq = '=';
-        } else {
-          const _this$tokenizer$_hook3 = this.tokenizer._hook({}),
-            _this$tokenizer$_hook4 = _slicedToArray(_this$tokenizer$_hook3, 3),
-            hookType = _this$tokenizer$_hook4[0],
-            value = _this$tokenizer$_hook4[1],
-            hookI = _this$tokenizer$_hook4[2];
-          const rawVal = data[aoye.Keys.Raw][value];
-          const isFn = typeof rawVal === 'function';
-          if (hookType === 'dynamic') {
-            const valueIsMapKey = Reflect.has(data[aoye.Keys.Raw], value);
-            const fn = isFn ? rawVal : valueIsMapKey ? value : this.getFn(data, value);
-            this.onePropParsed(data, _node, key, fn, valueIsMapKey, isFn, hookI);
-          } else if (hookType === 'static') {
-            this.onePropParsed(data, _node, key, value, false, isFn, hookI);
-          } else {
-            this.onePropParsed(data, _node, key, value, false, isFn, hookI);
-          }
-          key = null;
-          eq = null;
+    headerLineAndExtensions() {
+      const props = [];
+      props.push(...this.attributeList());
+      if (this.tokenizer.token.type & TokenType.NewLine) {
+        this.tokenizer.nextToken();
+      }
+      while (this.tokenizer.token.type & TokenType.Pipe) {
+        this.tokenizer.nextToken();
+        props.push(...this.attributeList());
+        if (this.tokenizer.token.type & TokenType.NewLine) {
+          this.tokenizer.nextToken();
         }
+      }
+      return props;
+    }
+    attributeList() {
+      const props = [];
+      while (!(this.tokenizer.token.type & TokenType.NewLine) && !(this.tokenizer.token.type & TokenType.Pipe) && !this.tokenizer.isEof()) {
+        props.push(this.parseProperty());
+      }
+      return props;
+    }
+    parseProperty(node) {
+      node.type = NodeType.Property;
+      node.key = this.parsePropertyKey();
+      const token = this.tokenizer.nextToken();
+      if (token.value === '=') {
+        this.tokenizer.nextToken();
+        node.value = this.parsePropertyValue();
         this.tokenizer.nextToken();
       }
+      node.loc.start = node.key.loc.start;
+      node.loc.end = node.value ? node.value.loc.end : node.key.loc.end;
+      node.loc.source = this.tokenizer.code.slice(node.loc.start.offset, node.loc.end.offset);
+      return node;
+    }
+    parsePropertyKey(node) {
+      node.type = NodeType.PropertyKey;
+      node.key = this.tokenizer.token.value;
+      return node;
     }
-    config(opt) {
-      Object.assign(this, opt);
-      this.opt = opt;
+    parsePropertyValue(node) {
+      const _this$tokenizer$_hook3 = this.tokenizer._hook({}),
+        _this$tokenizer$_hook4 = _slicedToArray(_this$tokenizer$_hook3, 2),
+        hookType = _this$tokenizer$_hook4[0],
+        value = _this$tokenizer$_hook4[1];
+      node.type = hookType === 'dynamic' ? NodeType.DynamicValue : NodeType.StaticValue;
+      node.value = value;
+      return node;
     }
-    createNode(name) {
-      return {
-        name,
-        props: {},
-        nextSibling: null
+  }
+  function NodeLoc(target, context) {
+    return function (_node) {
+      _node.loc.start = this.tokenizer.token.loc.start;
+      const result = target.call(this, _node);
+      _node.loc.end = this.tokenizer.token.loc ? this.tokenizer.token.loc.start : this.tokenizer.getCurrentPos();
+      _node.loc.source = this.tokenizer.code.slice(_node.loc.start.offset, _node.loc.end.offset);
+      return result;
+    };
+  }
+  function TokenLoc(target, context) {
+    return function (_node) {
+      const result = target.call(this, _node);
+      _node.loc = this.tokenizer.token.loc;
+      return result;
+    };
+  }
+  function NodeHook(target, context) {
+    return function (_node) {
+      const hook = this.hooks[context.name];
+      const node = {
+        loc: {}
+      };
+      hook?.enter?.call(this, node);
+      const result = target.call(this, node);
+      hook?.leave?.call(this, node);
+      return result;
+    };
+  }
+
+  class MultiTypeStack {
+    typeTops = {};
+    length = 0;
+    stack = [];
+    push(value, bits) {
+      const newNode = {
+        value,
+        types: bits,
+        prevByType: {}
       };
+      let bit;
+      while (1) {
+        bit = bits & ~bits + 1;
+        if (!bit) break;
+        bits &= ~bit;
+        newNode.prevByType[bit] = this.typeTops[bit] || undefined;
+        this.typeTops[bit] = newNode;
+      }
+      this.stack[this.length++] = newNode;
     }
-    nextSib(node) {
-      return node.nextSibling;
+    pop() {
+      const poppedNode = this.stack[this.length - 1];
+      this.stack[--this.length] = null;
+      if (!poppedNode) return undefined;
+      let bits = poppedNode.types;
+      let bit;
+      while (1) {
+        bit = bits & ~bits + 1;
+        if (!bit) break;
+        bits &= ~bit;
+        this.typeTops[bit] = poppedNode.prevByType[bit];
+      }
+      return [poppedNode.value, poppedNode.types];
     }
-    firstChild(node) {
-      return node.firstChild;
+    peekByType(cat) {
+      return this.typeTops[cat]?.value;
     }
-    createAnchor(name) {
-      return {
-        name,
-        nextSibling: null
-      };
+    peekType() {
+      return this.stack.at(-1).types;
     }
-    insertAfter(parent, node, prev) {
-      return this.defaultInsert(parent, node, prev);
+    peek() {
+      return this.stack.at(-1).value;
     }
-    defaultInsert(parent, node, prev) {
-      if (prev) {
-        const next = prev.nextSibling;
-        prev.nextSibling = node;
-        node.nextSibling = next;
-      } else {
-        const next = parent.firstChild;
-        parent.firstChild = node;
-        node.nextSibling = next;
+  }
+
+  function macInc(arr) {
+    const len = arr.length;
+    let candyLast = [],
+      i = 0;
+    while (i < len) {
+      const it = arr[i];
+      if (it !== -1) {
+        candyLast = [i];
+        break;
       }
+      i++;
     }
-    remove(node, parent, prev) {
-      return this.defaultRemove(node, parent, prev);
-    }
-    defaultRemove(node, parent, prevSibling) {
-      const next = node.nextSibling;
-      if (prevSibling) {
-        prevSibling.nextSibling = next;
-      }
-      if (parent.firstChild === node) {
-        parent.firstChild = next;
+    if (i + 1 >= len) return candyLast;
+    const toPrev = new Int32Array(len);
+    while (i < len) {
+      const target = arr[i];
+      if (target === -1) continue;
+      let start = -1,
+        end = candyLast.length;
+      while (start + 1 < end) {
+        const mid = start + end >> 1;
+        if (arr[candyLast[mid]] < target) {
+          start = mid;
+        } else {
+          end = mid;
+        }
       }
+      candyLast[end] = i;
+      toPrev[i] = candyLast[start];
+      i++;
     }
-    setProp(node, key, value, hookI) {
-      node.props[key] = value;
+    let length = candyLast.length;
+    for (let j = length - 1; j > 0; j--) {
+      const prev = toPrev[candyLast[j]];
+      candyLast[j - 1] = prev;
     }
+    return candyLast;
   }
 
-  class Tokenizer {
-    TabSize = 2;
-    Tab = Array.from({
-      length: this.TabSize
-    }, () => ' ').join('');
-    static EofId = `__EOF__${Date.now()}`;
-    static DedentId = `__DEDENT__${Date.now()}`;
-    needIndent = false;
-    isFirstToken = true;
-    dentStack = [0];
-    i = 0;
-    handledTokens = [];
-    waitingTokens = new bobeShared.Queue();
-    constructor(hook, useDedentAsEof) {
-      this.hook = hook;
-      this.useDedentAsEof = useDedentAsEof;
-      if (useDedentAsEof) {
-        this.setToken(TokenType.Indent, '');
-        this.isFirstToken = true;
+  const KEY_INDEX = '__BOBE_KEY_INDEX';
+
+  const _excluded = ["dentStack", "isFirstToken"];
+  class Interpreter {
+    constructor(tokenizer) {
+      this.tokenizer = tokenizer;
+    }
+    isLogicNode(node) {
+      return node && node.__logicType & LogicalBit;
+    }
+    rootComponent = null;
+    program(root, componentNode, before, ctxProvider) {
+      this.rootComponent = componentNode;
+      this.tokenizer.nextToken();
+      const stack = new MultiTypeStack();
+      stack.push({
+        node: root,
+        prev: null
+      }, NodeSort.Real);
+      stack.push({
+        node: componentNode,
+        prev: null
+      }, NodeSort.Component | NodeSort.CtxProvider | NodeSort.TokenizerSwitcher);
+      if (ctxProvider) {
+        stack.push({
+          node: ctxProvider,
+          prev: null
+        }, (ctxProvider.__logicType & LogicalBit ? NodeSort.Logic : 0) | NodeSort.CtxProvider);
+      }
+      const rootLen = stack.length;
+      const ctx = this.ctx = {
+        realParent: root,
+        prevSibling: before,
+        current: null,
+        stack,
+        before
+      };
+      const rootPulling = aoye.getPulling();
+      while (1) {
+        if (this.tokenizer.isEof()) {
+          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.nextToken();
+          const isLogicNode = this.isLogicNode(ctx.current);
+          stack.push({
+            node: ctx.current,
+            prev: ctx.prevSibling
+          }, !ctx.current.__logicType ? NodeSort.Real : (ctx.current.__logicType & LogicalBit ? NodeSort.Logic : 0) | (ctx.current.__logicType & TokenizerSwitcherBit ? NodeSort.TokenizerSwitcher : 0) | (ctx.current.__logicType === FakeType.Component ? NodeSort.Component : 0) | NodeSort.CtxProvider);
+          if (ctx.current.__logicType) {
+            if (isLogicNode) {
+              aoye.setPulling(ctx.current.effect);
+              if (ctx.current.__logicType & FakeType.ForItem) {
+                ctx.prevSibling = ctx.current.realBefore;
+              }
+            }
+          } else {
+            if (ctx.current) {
+              ctx.realParent = ctx.current;
+            }
+            ctx.prevSibling = null;
+          }
+          ctx.current = this.declaration(ctx);
+          continue;
+        }
+        if (ctx.current) {
+          if (stack.length === rootLen && !ctx.prevSibling) {
+            ctx.prevSibling = before;
+          }
+          this.handleInsert(ctx.realParent, ctx.current, ctx.prevSibling);
+        }
+        if (this.tokenizer.token.type & TokenType.Dedent) {
+          this.tokenizer.nextToken();
+          const _stack$pop = stack.pop(),
+            _stack$pop2 = _slicedToArray(_stack$pop, 2),
+            _stack$pop2$ = _stack$pop2[0],
+            parent = _stack$pop2$.node,
+            prev = _stack$pop2$.prev,
+            sort = _stack$pop2[1];
+          if (!parent.__logicType) {
+            const prevSameType = stack.peekByType(NodeSort.Real);
+            ctx.realParent = prevSameType?.node || root;
+          } else {
+            if (sort & NodeSort.Logic) {
+              const parentLogic = stack.peekByType(NodeSort.Logic)?.node;
+              if (parentLogic) {
+                aoye.setPulling(parentLogic.effect);
+              } else {
+                aoye.setPulling(rootPulling);
+              }
+            }
+            if (sort & NodeSort.TokenizerSwitcher) {
+              const switcher = stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
+              this.tokenizer = switcher.tokenizer;
+            }
+            if (parent.__logicType === FakeType.ForItem) {
+              const _ref = parent,
+                forNode = _ref.forNode;
+              const i = forNode.i,
+                arr = forNode.arr,
+                snapshot = forNode.snapshot;
+              if (i + 1 < arr.length) {
+                this.tokenizer.resume(snapshot);
+                this.tokenizer.nextToken();
+                this.tokenizer.nextToken();
+                ctx.current = forNode.children[++forNode.i];
+                ctx.prevSibling = ctx.current.realBefore;
+                continue;
+              }
+              ctx.prevSibling = forNode.prevSibling;
+              ctx.current = forNode;
+              continue;
+            }
+          }
+          ctx.prevSibling = prev;
+          ctx.current = parent;
+        } else {
+          ctx.prevSibling = ctx.current || ctx.prevSibling;
+          ctx.current = this.declaration(ctx);
+        }
       }
+      return componentNode;
     }
-    consume() {
-      const token = this.token;
-      this.nextToken();
-      return token;
-    }
-    resume(_snapshot) {
-      this.token = undefined;
-      this.needIndent = false;
-      this.isFirstToken = true;
-      this.dentStack = [0];
-      Object.assign(this, _snapshot);
+    insertAfterAnchor(name = 'anchor') {
+      const _this$ctx = this.ctx,
+        realParent = _this$ctx.realParent,
+        prevSibling = _this$ctx.prevSibling,
+        stack = _this$ctx.stack,
+        before = _this$ctx.before;
+      const afterAnchor = this.createAnchor(name);
+      this.ctx.prevSibling = stack.length === 2 && !prevSibling ? before : prevSibling;
+      this.handleInsert(realParent, afterAnchor, prevSibling);
+      return afterAnchor;
     }
-    snapshot(keys) {
-      const snap = {
-        i: this.i,
-        waitingTokens: this.waitingTokens.clone()
-      };
-      if (keys) {
-        for (const k of keys) {
-          snap[k] = this[k];
-          if (k === 'dentStack') {
-            snap[k] = this[k].slice();
-          }
+    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 {
+        const childCmp = child;
+        childCmp.realParent = parent;
+        if (prev?.__logicType) {
+          childCmp.realBefore = prev.forNode ? prev.forNode.realAfter : prev.realAfter;
+        } else {
+          childCmp.realBefore = prev;
         }
       }
-      return snap;
     }
-    skip() {
-      const logicDentLen = this.dentStack[this.dentStack.length - 1];
-      let needIndent = false;
-      let skipFragment = ``;
-      this.token = undefined;
-      while (1) {
-        const char = this.code[this.i];
-        if (char === '\n') {
-          needIndent = true;
-          skipFragment += char;
-          this.i++;
-          continue;
-        }
-        if (!needIndent) {
-          skipFragment += char;
-          this.i++;
-          continue;
+    getPrevRealSibling(prevSibling) {
+      if (!prevSibling || !prevSibling.__logicType) {
+        return prevSibling;
+      }
+      let point = prevSibling;
+      while (point != null) {
+        if (point.lastChild) {
+          return point.lastChild.value;
         }
-        needIndent = false;
-        const _this$getDentValue = this.getDentValue(),
-          value = _this$getDentValue.value,
-          isEmptyLine = _this$getDentValue.isEmptyLine;
-        const currLen = value.length;
-        if (isEmptyLine) continue;
-        if (currLen > logicDentLen) {
-          skipFragment += value;
+        point = point.anchor;
+      }
+    }
+    declaration(ctx) {
+      const _this$tokenizer$_hook = this.tokenizer._hook({}),
+        _this$tokenizer$_hook2 = _slicedToArray(_this$tokenizer$_hook, 2),
+        hookType = _this$tokenizer$_hook2[0],
+        value = _this$tokenizer$_hook2[1];
+      let _node;
+      if (value === 'if' || value === 'else' || value === 'fail') {
+        return this.condDeclaration(ctx);
+      } else if (value === 'for') {
+        return this.forDeclaration();
+      } else if (hookType) {
+        const data = this.getData();
+        if (hookType === 'static') {
+          if (typeof value === 'function') {
+            _node = this.componentOrFragmentDeclaration(value, ctx);
+          } else {
+            throw new SyntaxError(`declaration 不支持 ${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(`缩进错误，缩进长度不匹配`);
-            }
-            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)
-              });
-            }
+          const valueIsMapKey = Reflect.has(data[aoye.Keys.Raw], value);
+          const val = data[aoye.Keys.Raw][value];
+          if (typeof val === 'function') {
+            _node = this.componentOrFragmentDeclaration(val, ctx);
+          } else {
+            const str = valueIsMapKey ? value : this.getFn(data, value);
+            _node = this.createNode('text');
+            this.onePropParsed(data, _node, 'text', str, valueIsMapKey, false);
           }
-          break;
         }
+      } else {
+        _node = this.createNode(value);
       }
-      if (!this.token) {
-        this.nextToken();
+      this.tokenizer.nextToken();
+      this.headerLine(_node);
+      this.extensionLines(_node);
+      if (_node.__logicType & TokenizerSwitcherBit) {
+        this.onePropParsed = this.oneRealPropParsed;
+        this.tokenizer = _node.tokenizer;
       }
-      return skipFragment;
-    }
-    setCode(code) {
-      this.code = '\n' + code.trimEnd() + `\n${Tokenizer.EofId}`;
-    }
-    tokenize() {
-      do {
-        this.nextToken();
-        console.log('token:', TokenType[this.token?.type], JSON.stringify(this.token?.value || ''));
-      } while (!this.isEof());
-    }
-    isEof() {
-      if (!this.token) return false;
-      return this.token.type & TokenType.Identifier && this.token.value === Tokenizer.EofId;
-    }
-    setToken(type, value) {
-      this.token = {
-        type,
-        typeName: TokenType[type],
-        value
-      };
-      this.isFirstToken = false;
+      return _node;
     }
-    nextToken() {
-      try {
-        if (this.isEof()) {
-          return this.token;
-        }
-        this.token = undefined;
-        if (this.waitingTokens.len) {
-          const item = this.waitingTokens.shift();
-          this.setToken(item.type, item.value);
-          return this.token;
+    forDeclaration() {
+      const arrExp = this.tokenizer.nextToken().value;
+      this.tokenizer.nextToken();
+      const itemToken = this.tokenizer.nextToken();
+      const isDestruct = itemToken.type === TokenType.InsertionExp;
+      let itemExp = itemToken.value,
+        vars;
+      if (isDestruct) {
+        itemExp = '{' + itemExp + '}';
+        vars = itemExp.match(bobeShared.jsVarRegexp);
+        const varStr = vars.join(',');
+        itemExp = new Function(itemExp, `return {${varStr}};`);
+      }
+      let indexName,
+        keyExp,
+        char = this.tokenizer.peekChar();
+      if (char === ';') {
+        this.tokenizer.nextToken();
+        if (this.tokenizer.peekChar() !== '\n') keyExp = this.tokenizer.jsExp().value;
+      } else if (char === '\n') ; else {
+        indexName = this.tokenizer.nextToken().value;
+        if (this.tokenizer.peekChar() === ';') {
+          this.tokenizer.nextToken();
+          if (this.tokenizer.peekChar() !== '\n') keyExp = this.tokenizer.jsExp().value;
         }
-        outer: while (1) {
-          if (this.needIndent) {
-            this.dent();
+      }
+      const owner = this.ctx.stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
+      const prevSibling = this.ctx.prevSibling;
+      const forNode = {
+        __logicType: FakeType.For,
+        snapshot: this.tokenizer.snapshot(['dentStack', 'isFirstToken']),
+        realParent: this.ctx.realParent,
+        prevSibling,
+        realBefore: prevSibling?.realAfter || prevSibling,
+        realAfter: null,
+        arr: null,
+        arrSignal: null,
+        itemExp,
+        indexName,
+        getKey: null,
+        children: [],
+        effect: null,
+        owner,
+        vars,
+        i: 0
+      };
+      if (keyExp) {
+        forNode.getKey = new Function('data', `let v;with(data){v=${keyExp}};return v;`);
+      }
+      window['for1'] = forNode;
+      const data = this.getData();
+      const cells = data[aoye.Keys.Meta].cells;
+      const hasArrExpKey = Reflect.has(data[aoye.Keys.Raw], arrExp);
+      const arrSignal = hasArrExpKey ? (data[arrExp], cells.get(arrExp)) : new aoye.Computed(this.getFn(data, arrExp));
+      forNode.arrSignal = arrSignal;
+      forNode.realAfter = this.insertAfterAnchor('for-after');
+      const _forNode$snapshot = forNode.snapshot;
+        _forNode$snapshot.dentStack;
+        _forNode$snapshot.isFirstToken;
+        const snapshotForUpdate = _objectWithoutProperties(_forNode$snapshot, _excluded);
+      let isFirstRender = true;
+      forNode.effect = new aoye.Effect(() => {
+        let arr = arrSignal.get();
+        arr[aoye.Keys.Iterator];
+        const prevCtx = aoye.getPulling();
+        aoye.setPulling(null);
+        forNode.arr = arr = aoye.toRaw(arr);
+        const children = forNode.children;
+        if (isFirstRender) {
+          const len = arr.length;
+          for (let i = len; i--;) {
+            const item = this.createForItem(forNode, i, data);
+            item.realAfter = this.insertAfterAnchor('for-item-after');
+            item.realBefore = this.insertAfterAnchor('for-item-before');
+            item.realParent = forNode.realParent;
+            children[i] = item;
+          }
+          const firstInsert = children[0];
+          if (firstInsert) {
+            this.tokenizer.nextToken();
+            this.tokenizer.nextToken();
           } else {
-            const char = this.code[this.i];
-            switch (char) {
-              case '\t':
-              case ' ':
-                break;
-              case '\n':
-                this.newLine();
-                this.needIndent = true;
-                break;
-              case '=':
-                this.assignment();
-                break;
-              case '|':
-                this.pipe();
-                break;
-              case "'":
-              case '"':
-                this.str(char);
-                break;
-              case '{':
-                const braceToken = this.brace();
-                this.setToken(TokenType.InsertionExp, braceToken);
+            this.tokenizer.skip();
+          }
+        } else {
+          const oldLen = children.length;
+          const newLen = arr.length;
+          const minLen = Math.min(oldLen, newLen);
+          const newChildren = [];
+          if (!forNode.getKey) {
+            if (newLen < oldLen) {
+              for (let i = oldLen - 1; i >= newLen; i--) {
+                this.removeForItem(children, i);
+              }
+            }
+            if (oldLen < newLen) {
+              const lastAfter = children.at(-1)?.realAfter || forNode.realBefore;
+              for (let i = newLen - 1; i >= oldLen; i--) {
+                this.insertForItem(forNode, i, data, newChildren, lastAfter, snapshotForUpdate);
+              }
+            }
+            for (let i = minLen; i--;) {
+              const child = children[i];
+              newChildren[i] = child;
+              this.reuseForItem(child, arr[i], itemExp, i, indexName);
+            }
+          } else {
+            let s = 0,
+              e1 = oldLen - 1,
+              e2 = newLen - 1;
+            while (s <= e1 && s <= e2) {
+              const child = children[s];
+              const old = child.key;
+              const itemData = this.getItemData(forNode, s, data);
+              const key = forNode.getKey(itemData);
+              if (old === key) {
+                newChildren[s] = child;
+                this.reuseForItem(child, arr[s], itemExp, s, indexName);
+                s++;
+              } else {
                 break;
-              case '$':
-                const handled = this.dynamic(char);
-                if (handled) break;
-              case ';':
-                this.setToken(TokenType.Semicolon, ';');
+              }
+            }
+            while (s <= e1 && s <= e2) {
+              const child = children[e1];
+              const old = child.key;
+              const itemData = this.getItemData(forNode, e2, data);
+              const key = forNode.getKey(itemData);
+              if (old === key) {
+                newChildren[e2] = child;
+                this.reuseForItem(child, arr[e2], itemExp, e2, indexName);
+                e1--;
+                e2--;
+              } else {
                 break;
-              default:
-                if (bobeShared.isNum(char)) {
-                  this.number(char);
-                  break;
+              }
+            }
+            if (s > e1) {
+              if (s <= e2) {
+                const firstBefore = s > 0 ? children[s - 1]?.realAfter || forNode.realBefore : forNode.realBefore;
+                for (let i = e2; i >= s; i--) {
+                  this.insertForItem(forNode, i, data, newChildren, firstBefore, snapshotForUpdate);
                 }
-                if (typeof char === 'string' && bobeShared.matchIdStart2(char, 0)) {
-                  this.identifier(char);
+              }
+            } else if (s > e2) {
+              if (s <= e1) {
+                for (let i = e1; i >= s; i--) {
+                  this.removeForItem(children, i);
                 }
-                break;
+              }
+            } else {
+              let s1 = s,
+                s2 = s;
+              const mixLen = e2 - s2 + 1;
+              const key2new = new Map();
+              for (let i = s2; i <= e2; i++) {
+                const itemData = this.getItemData(forNode, i, data);
+                const key = forNode.getKey(itemData);
+                key2new.set(key, i);
+              }
+              let maxIncNewI = -1;
+              let hasMove = false;
+              const new2oldI = new Array(mixLen).fill(-1);
+              for (let i = s1; i <= e1; i++) {
+                const key = children[i].key;
+                const newI = key2new.get(key);
+                if (newI == null) {
+                  this.removeForItem(children, i);
+                  continue;
+                }
+                const child = children[i];
+                newChildren[newI] = child;
+                this.reuseForItem(child, arr[newI], itemExp, newI, indexName);
+                new2oldI[newI - s2] = i;
+                key2new.delete(key);
+                if (newI < maxIncNewI) {
+                  hasMove = true;
+                } else {
+                  maxIncNewI = newI;
+                }
+              }
+              if (!hasMove) {
+                key2new.forEach((i, key) => {
+                  const before = i === 0 ? forNode.realBefore : newChildren[i - 1].realAfter;
+                  this.insertForItem(forNode, i, data, newChildren, before, snapshotForUpdate);
+                });
+              } else {
+                const incI = macInc(new2oldI),
+                  incLen = incI.length;
+                let p1, p2;
+                for (p1 = s2, p2 = 0; p1 <= e2; p1++) {
+                  const oldI = new2oldI[p1];
+                  if (oldI === -1) {
+                    const before = p1 === 0 ? forNode.realBefore : newChildren[p1 - 1].realAfter;
+                    this.insertForItem(forNode, p1, data, newChildren, before, snapshotForUpdate);
+                    continue;
+                  }
+                  const staticIdx = incI[p2] + s2;
+                  if (p1 === staticIdx) {
+                    p2 <= incLen && p2++;
+                    continue;
+                  }
+                  let before = p1 === 0 ? forNode.realBefore : newChildren[p1 - 1].realAfter;
+                  const child = newChildren[p1];
+                  const realBefore = child.realBefore,
+                    realAfter = child.realAfter,
+                    realParent = child.realParent;
+                  let point = realBefore,
+                    next;
+                  do {
+                    next = this.nextSib(point);
+                    this.insertAfter(realParent, point, before);
+                    before = point;
+                    if (point === realAfter) break;
+                    point = next;
+                  } while (true);
+                }
+              }
             }
-            this.i++;
           }
-          if (this.token) {
-            break;
+          forNode.children = newChildren;
+        }
+        isFirstRender = false;
+        aoye.setPulling(prevCtx);
+        return isDestroy => {
+          if (isDestroy) {
+            for (let i = 0; i < forNode.children.length; i++) {
+              const item = forNode.children[i];
+              item.effect.dispose();
+            }
           }
+        };
+      });
+      return forNode.children[0] || forNode;
+    }
+    insertForItem(forNode, i, parentData, newChildren, before, snapshotForUpdate) {
+      const item = this.createForItem(forNode, i, parentData);
+      newChildren[i] = item;
+      let realAfter = this.createAnchor('for-item-after');
+      this.handleInsert(forNode.realParent, realAfter, before);
+      let realBefore = this.createAnchor('for-item-before');
+      this.handleInsert(forNode.realParent, realBefore, before);
+      item.realBefore = realBefore;
+      item.realAfter = realAfter;
+      this.tokenizer = forNode.owner.tokenizer;
+      this.tokenizer.resume(snapshotForUpdate);
+      this.tokenizer.useDedentAsEof = false;
+      aoye.runWithPulling(() => {
+        this.program(forNode.realParent, forNode.owner, realBefore, item);
+      }, item.effect);
+    }
+    removeForItem(children, i) {
+      const child = children[i];
+      this.removeLogicNode(child);
+      this.remove(child.realBefore);
+      this.remove(child.realAfter);
+      child.effect.dispose();
+    }
+    reuseForItem(child, data, itemExp, i, indexName) {
+      if (typeof itemExp === 'string') {
+        child.data[itemExp] = data;
+        if (indexName) {
+          child.data[indexName] = i;
         }
-        return this.token;
-      } catch (error) {
-        console.error(error);
-        return this.token;
-      } finally {
-        this.handledTokens.push(this.token);
+      } else {
+        indexName = indexName || KEY_INDEX;
+        child.data[indexName] = i;
       }
     }
-    condExp() {
-      let value = '';
-      this.token = null;
-      while (1) {
-        const char = this.code[this.i];
-        if (char === '\n') {
-          break;
+    forItemId = 0;
+    createForItem(forNode, i, parentData) {
+      let forItemNode;
+      let data;
+      const scope = new aoye.Scope(() => {});
+      scope.scope = null;
+      aoye.runWithPulling(() => {
+        scope.get();
+      }, null);
+      data = this.getItemData(forNode, i, parentData);
+      forItemNode = {
+        id: this.forItemId++,
+        __logicType: FakeType.ForItem,
+        realParent: null,
+        realBefore: null,
+        realAfter: null,
+        forNode,
+        key: forNode.getKey?.(data),
+        effect: null,
+        data
+      };
+      forItemNode.effect = scope;
+      return forItemNode;
+    }
+    getItemData(forNode, i, parentData) {
+      const arr = forNode.arr,
+        itemExp = forNode.itemExp,
+        vars = forNode.vars,
+        arrSignal = forNode.arrSignal,
+        getKey = forNode.getKey;
+      let indexName = forNode.indexName;
+      let data;
+      if (typeof itemExp === 'string') {
+        data = aoye.deepSignal(indexName ? {
+          [itemExp]: arr[i],
+          [indexName]: i
+        } : {
+          [itemExp]: arr[i]
+        }, aoye.getPulling());
+      } else {
+        indexName = indexName ?? KEY_INDEX;
+        const rawData = {
+          [indexName]: i
+        };
+        data = aoye.deepSignal(rawData, aoye.getPulling());
+        const computedData = new aoye.Computed(() => itemExp(arrSignal.get()[getKey ? data[indexName] : i]));
+        const cells = data[aoye.Keys.Meta].cells;
+        for (let i = 0; i < vars.length; i++) {
+          const name = vars[i];
+          rawData[name] = undefined;
+          cells.set(name, new aoye.Computed(() => computedData.get()[name]));
         }
-        value += char;
-        this.i++;
       }
-      value = value.trim();
-      this.setToken(TokenType.Identifier, value || true);
-      return this.token;
+      Object.setPrototypeOf(data, parentData);
+      return data;
     }
-    jsExp() {
-      this.token = null;
-      let value = '';
-      while (1) {
-        const char = this.code[this.i];
-        if (char === ';' || char === '\n') {
-          this.setToken(TokenType.Identifier, value.trim());
-          return this.token;
-        } else {
-          value += char;
-        }
-        this.i++;
-      }
+    getData() {
+      const _this$ctx$stack$peekB = this.ctx.stack.peekByType(NodeSort.CtxProvider),
+        node = _this$ctx$stack$peekB.node;
+      return node.data;
     }
-    peekChar() {
-      let i = this.i;
-      while (this.code[i] === ' ' || this.code[i] === '\t') {
-        i++;
+    onePropParsed(data, node, key, value, valueIsMapKey, isFn, hookI) {
+      if (isFn) {
+        this.setProp(node, key, value, hookI);
+      } else if (typeof value === 'function') {
+        new aoye.Effect(() => {
+          const res = value();
+          this.setProp(node, key, res, hookI);
+        });
+      } else if (valueIsMapKey) {
+        new aoye.Effect(() => {
+          const res = data[value];
+          this.setProp(node, key, res, hookI);
+        });
+      } else {
+        this.setProp(node, key, value, hookI);
       }
-      return this.code[i];
-    }
-    assignment() {
-      this.setToken(TokenType.Assign, '=');
-    }
-    pipe() {
-      this.setToken(TokenType.Pipe, '|');
     }
-    dynamic(char) {
-      let nextC = this.code[this.i + 1];
-      if (nextC !== '{') {
-        return false;
-      }
-      this.i++;
-      let value = '${';
-      let innerBrace = 0;
-      while (1) {
-        nextC = this.code[this.i + 1];
-        value += nextC;
-        this.i++;
-        if (nextC === '{') {
-          innerBrace++;
-        }
-        if (nextC === '}') {
-          if (!innerBrace) {
-            break;
-          }
-          innerBrace--;
-        }
+    oneRealPropParsed = this.onePropParsed.bind(this);
+    componentOrFragmentDeclaration(ComponentOrRender, ctx) {
+      let Component, render, child;
+      const isCC = ComponentOrRender.prototype instanceof aoye.Store;
+      if (isCC) {
+        Component = ComponentOrRender;
+        child = Component.new();
+      } else {
+        render = ComponentOrRender;
+        const boundStore = render.boundStore;
+        child = aoye.deepSignal({}, aoye.getPulling(), true);
+        Object.setPrototypeOf(child, boundStore);
       }
-      this.setToken(TokenType.Identifier, value);
-      return true;
-    }
-    brace() {
-      let inComment,
-        inString,
-        count = 0,
-        value = '',
-        backslashCount = 0;
-      while (1) {
-        const char = this.code[this.i];
-        const nextChar = this.code[this.i + 1];
-        if (inComment === 'single' && char === '\n') {
-          inComment = null;
-        } else if (inComment === 'multi' && char === '*' && nextChar === '/') {
-          inComment = null;
-          value += this.code[this.i];
-          this.i++;
-        } else if (inString) {
-          if (char === inString && backslashCount % 2 === 0) {
-            inString = null;
-          }
-          backslashCount = char === '\\' ? backslashCount + 1 : 0;
+      const node = {
+        __logicType: isCC ? FakeType.Component : FakeType.Fragment,
+        realParent: ctx.realParent,
+        realBefore: null,
+        realAfter: null,
+        data: child,
+        tokenizer: render ? render(true) : child['ui'](true)
+      };
+      this.onePropParsed = (data, _, key, value, valueIsMapKey, isFn, hookI) => {
+        if (isFn) {
+          child[aoye.Keys.Raw][key] = value;
+        } else if (valueIsMapKey) {
+          aoye.shareSignal(data, value, child, key);
         } else {
-          if (char === '/' && nextChar === '/') {
-            inComment = 'single';
-            value += this.code[this.i];
-            this.i++;
-          } else if (char === '/' && nextChar === '*') {
-            inComment = 'multi';
-            value += this.code[this.i];
-            this.i++;
-          } else if (char === "'" || char === '"' || char === '`') {
-            inString = char;
-          } else if (char === '{') {
-            count++;
-          } else if (char === '}') {
-            count--;
+          const meta = child[aoye.Keys.Meta];
+          const cells = meta.cells;
+          if (typeof value === 'function') {
+            const computed = new aoye.Computed(value);
+            cells.set(key, computed);
+            child[aoye.Keys.Raw][key] = undefined;
+          } else {
+            cells.set(key, {
+              get: () => value
+            });
+            child[aoye.Keys.Raw][key] = value;
           }
         }
-        if (count === 0 && inString == null && inComment == null) {
-          return value.slice(1);
-        }
-        value += this.code[this.i];
-        this.i++;
-      }
+      };
+      node.realAfter = this.insertAfterAnchor('component-after');
+      return node;
     }
-    newLine() {
-      let value = '\n';
-      let nextC;
-      while (1) {
-        nextC = this.code[this.i + 1];
-        if (nextC !== '\n') {
-          break;
-        }
-        value += nextC;
-        this.i++;
-      }
-      if (this.isFirstToken) {
-        return;
-      }
-      this.setToken(TokenType.NewLine, value);
+    getFn(data, expression) {
+      return new Function('data', `let v;with(data){v=${expression}};return v;`).bind(undefined, data);
     }
-    getDentValue() {
-      let value = '';
-      let nextC;
-      let isEmptyLine = false;
-      while (1) {
-        const nextChar = this.code[this.i];
-        switch (nextChar) {
-          case '\t':
-            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.i++;
-      }
-      return {
-        value,
-        isEmptyLine
+    condDeclaration(ctx) {
+      const prevSibling = ctx.prevSibling;
+      const keyWord = this.tokenizer.token;
+      const expToken = this.tokenizer.condExp();
+      const value = expToken.value;
+      const isElse = keyWord.value === 'else';
+      const isIf = keyWord.value === 'if';
+      const preIsCond = prevSibling?.__logicType & CondBit;
+      const data = this.getData();
+      const noCond = value === true;
+      const valueIsMapKey = !noCond && Reflect.has(data[aoye.Keys.Raw], value);
+      const owner = ctx.stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
+      const ifNode = {
+        __logicType: isElse ? FakeType.Else : isIf ? FakeType.If : FakeType.Fail,
+        snapshot: this.tokenizer.snapshot(),
+        realParent: null,
+        realBefore: null,
+        realAfter: null,
+        condition: null,
+        preCond: preIsCond ? prevSibling : null,
+        isFirstRender: true,
+        effect: null,
+        owner,
+        data
       };
-    }
-    dent() {
-      const _this$getDentValue2 = this.getDentValue(),
-        value = _this$getDentValue2.value,
-        isEmptyLine = _this$getDentValue2.isEmptyLine;
-      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, 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('缩进大小不统一');
-          }
-          if (this.shorterThanBaseDentEof()) {
-            return;
+      let signal;
+      switch (keyWord.value) {
+        case 'if':
+          if (valueIsMapKey) {
+            aoye.runWithPulling(() => data[value], null);
+            const cells = data[aoye.Keys.Meta].cells;
+            signal = cells.get(value);
+          } else {
+            const fn = this.getFn(data, value);
+            signal = new aoye.Computed(fn);
           }
-          this.dentStack.pop();
-          if (!this.token) {
-            this.setToken(TokenType.Dedent, String(expLen));
+          break;
+        case 'else':
+          if (noCond) {
+            signal = new aoye.Computed(() => {
+              let point = ifNode.preCond;
+              while (point) {
+                if (point.condition.get()) {
+                  return false;
+                }
+                if (point.__logicType === FakeType.If) {
+                  break;
+                }
+                point = point.preCond;
+              }
+              return true;
+            });
           } else {
-            this.waitingTokens.push({
-              type: TokenType.Dedent,
-              typeName: TokenType[TokenType.Dedent],
-              value: String(expLen)
+            const fn = valueIsMapKey ? null : this.getFn(data, value);
+            signal = new aoye.Computed(() => {
+              let point = ifNode.preCond;
+              while (point) {
+                if (point.condition.get()) {
+                  return false;
+                }
+                if (point.__logicType === FakeType.If) {
+                  break;
+                }
+                point = point.preCond;
+              }
+              return valueIsMapKey ? data[value] : fn();
             });
           }
-        }
-        return indentHasLen;
+          break;
+        case 'fail':
+          signal = new aoye.Computed(() => {
+            let point = ifNode.preCond;
+            while (point) {
+              if (point.condition.get()) {
+                return false;
+              }
+              point = point.preCond;
+            }
+            return true;
+          });
+          break;
       }
-      return indentHasLen;
-    }
-    shorterThanBaseDentEof() {
-      const yes = this.dentStack.length === 1;
-      if (yes) {
-        if (!this.token) {
-          if (this.useDedentAsEof) {
-            this.setToken(TokenType.Dedent, '');
+      ifNode.condition = signal;
+      ifNode.realAfter = this.insertAfterAnchor(`${keyWord.value}-after`);
+      const ef = aoye.effect(({
+        val
+      }) => {
+        if (val) {
+          if (ifNode.isFirstRender) {
+            this.tokenizer.nextToken();
+            this.tokenizer.nextToken();
           } else {
-            this.setToken(TokenType.Identifier, Tokenizer.EofId);
+            this.tokenizer = ifNode.owner.tokenizer;
+            this.tokenizer.resume(ifNode.snapshot);
+            this.tokenizer.useDedentAsEof = false;
+            this.program(ifNode.realParent, ifNode.owner, ifNode.realBefore, ifNode);
           }
         } else {
-          if (this.useDedentAsEof) {
-            this.waitingTokens.push({
-              type: TokenType.Dedent,
-              typeName: TokenType[TokenType.Dedent],
-              value: ''
-            });
+          if (ifNode.isFirstRender) {
+            this.tokenizer.skip();
           } else {
-            this.waitingTokens.push({
-              type: TokenType.Identifier,
-              typeName: TokenType[TokenType.Identifier],
-              value: Tokenizer.EofId
-            });
+            this.removeLogicNode(ifNode);
           }
         }
+        ifNode.isFirstRender = false;
+      }, [signal]);
+      ifNode.effect = ef;
+      return ifNode;
+    }
+    removeLogicNode(node) {
+      const realBefore = node.realBefore,
+        realAfter = node.realAfter,
+        realParent = node.realParent;
+      let point = realBefore ? this.nextSib(realBefore) : this.firstChild(realParent);
+      while (point !== realAfter) {
+        const next = this.nextSib(point);
+        this.remove(point, realParent, realBefore);
+        point = next;
       }
-      return yes;
     }
-    identifier(char) {
-      let value = char;
-      let nextC;
+    extensionLines(_node) {
       while (1) {
-        nextC = this.code[this.i + 1];
-        if (typeof nextC !== 'string' || !bobeShared.matchIdStart2(nextC, 0)) {
-          break;
+        if ((this.tokenizer.token.type & TokenType.Pipe) === 0) {
+          return;
         }
-        value += nextC;
-        this.i++;
-      }
-      if (value === Tokenizer.EofId && this.useDedentAsEof) {
-        this.setToken(TokenType.Dedent, '');
-        return;
+        this.tokenizer.nextToken();
+        this.attributeList(_node);
+        if ((this.tokenizer.token.type & TokenType.NewLine) === 0) {
+          return;
+        }
+        this.tokenizer.nextToken();
       }
-      let realValue = value === 'null' ? null : value === 'undefined' ? undefined : 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.code[this.i + 1];
-        const memoCount = continuousBackslashCount;
-        if (nextC === '\\') {
-          continuousBackslashCount++;
+    headerLine(_node) {
+      this.attributeList(_node);
+      this.tokenizer.nextToken();
+    }
+    attributeList(_node) {
+      let key, eq;
+      const data = this.getData();
+      while ((this.tokenizer.token.type & TokenType.NewLine) === 0) {
+        if (key == null) {
+          key = this.tokenizer.token.value;
+        } else if (eq == null) {
+          eq = '=';
         } else {
-          continuousBackslashCount = 0;
-        }
-        this.i++;
-        if (nextC === char && memoCount % 2 === 0) {
-          break;
+          const _this$tokenizer$_hook3 = this.tokenizer._hook({}),
+            _this$tokenizer$_hook4 = _slicedToArray(_this$tokenizer$_hook3, 3),
+            hookType = _this$tokenizer$_hook4[0],
+            value = _this$tokenizer$_hook4[1],
+            hookI = _this$tokenizer$_hook4[2];
+          const rawVal = data[aoye.Keys.Raw][value];
+          const isFn = typeof rawVal === 'function';
+          if (hookType === 'dynamic') {
+            const valueIsMapKey = Reflect.has(data[aoye.Keys.Raw], value);
+            const fn = isFn ? rawVal : valueIsMapKey ? value : this.getFn(data, value);
+            this.onePropParsed(data, _node, key, fn, valueIsMapKey, isFn, hookI);
+          } else if (hookType === 'static') {
+            this.onePropParsed(data, _node, key, value, false, isFn, hookI);
+          } else {
+            this.onePropParsed(data, _node, key, value, false, isFn, hookI);
+          }
+          key = null;
+          eq = null;
         }
-        value += nextC;
+        this.tokenizer.nextToken();
       }
-      this.setToken(TokenType.Identifier, value);
     }
-    number(char) {
-      let value = char;
-      let nextC;
-      while (1) {
-        nextC = this.code[this.i + 1];
-        if (!bobeShared.isNum(nextC)) {
-          break;
-        }
-        value += nextC;
-        this.i++;
+    config(opt) {
+      Object.assign(this, opt);
+      this.opt = opt;
+    }
+    createNode(name) {
+      return {
+        name,
+        props: {},
+        nextSibling: null
+      };
+    }
+    nextSib(node) {
+      return node.nextSibling;
+    }
+    firstChild(node) {
+      return node.firstChild;
+    }
+    createAnchor(name) {
+      return {
+        name,
+        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 {
+        const next = parent.firstChild;
+        parent.firstChild = node;
+        node.nextSibling = next;
       }
-      this.setToken(TokenType.Identifier, Number(value));
     }
-    eof() {
-      this.setToken(TokenType.Eof, 'End Of File');
+    remove(node, parent, prev) {
+      return this.defaultRemove(node, parent, prev);
     }
-    HookId = '_h_o_o_k_';
-    hookI = 0;
-    _hook = props => {
-      const value = this.token.value;
-      const isDynamicHook = this.token.type & TokenType.InsertionExp;
-      const isStaticHook = typeof value === 'string' && value.indexOf(this.HookId) === 0;
-      const hookType = isDynamicHook ? 'dynamic' : isStaticHook ? 'static' : undefined;
-      if (this.hook && isStaticHook) {
-        const hookI = Number(value.slice(this.HookId.length));
-        const res = this.hook({
-          ...props,
-          HookId: this.HookId,
-          i: hookI
-        });
-        return [hookType, res, hookI];
-      } else if (isDynamicHook) {
-        return [hookType, value];
+    defaultRemove(node, parent, prevSibling) {
+      const next = node.nextSibling;
+      if (prevSibling) {
+        prevSibling.nextSibling = next;
       }
-      return [hookType, value];
-    };
-    init(fragments) {
-      if (typeof fragments === 'string') {
-        this.setCode(fragments);
-      } else {
-        let code = '';
-        for (let i = 0; i < fragments.length - 1; i++) {
-          const fragment = fragments[i];
-          code += fragment + `${this.HookId}${i}`;
-        }
-        this.setCode(code + fragments[fragments.length - 1]);
+      if (parent.firstChild === node) {
+        parent.firstChild = next;
       }
     }
+    setProp(node, key, value, hookI) {
+      node.props[key] = value;
+    }
   }
 
   function bobe(fragments, ...values) {
@@ -1566,6 +1993,9 @@
     };
   }
 
+  exports.Compiler = Compiler;
+  exports.NodeType = NodeType;
+  exports.Tokenizer = Tokenizer;
   exports.bobe = bobe;
   exports.customRender = customRender;
   Object.keys(aoye).forEach(function (k) {