bobe 0.0.31 → 0.0.33

package/dist/bobe.esm.js

@@ -1,75 +1,6 @@
+import { Queue, isNum, matchIdStart2, jsVarRegexp } from 'bobe-shared';
 import { getPulling, setPulling, Keys, Computed, Effect, toRaw, runWithPulling, Scope, deepSignal, Store, shareSignal, effect } from 'aoye';
 export * from 'aoye';
-import { jsVarRegexp, Queue, isNum, matchIdStart2 } from 'bobe-shared';
-
-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;
-  }
-}
 
 let TokenType = function (TokenType) {
   TokenType[TokenType["NewLine"] = 1] = "NewLine";
@@ -81,6 +12,7 @@ let TokenType = function (TokenType) {
   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) {
@@ -111,1427 +43,1922 @@ let NodeSort = function (NodeSort) {
   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 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 = 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) {
-            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) {
-              setPulling(parentLogic.effect);
-            } else {
-              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 (isNum(char)) {
+                    this.number(char);
+                    break;
+                  }
+                  if (typeof char === 'string' && 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[Keys.Raw], value);
-        const val = data[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(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[Keys.Meta].cells;
-    const hasArrExpKey = Reflect.has(data[Keys.Raw], arrExp);
-    const arrSignal = hasArrExpKey ? (data[arrExp], cells.get(arrExp)) : new 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 Effect(() => {
-      let arr = arrSignal.get();
-      arr[Keys.Iterator];
-      const prevCtx = getPulling();
-      setPulling(null);
-      forNode.arr = arr = 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;
-      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;
-    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' || !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 (!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 Scope(() => {});
-    scope.scope = null;
-    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 = deepSignal(indexName ? {
-        [itemExp]: arr[i],
-        [indexName]: i
-      } : {
-        [itemExp]: arr[i]
-      }, 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 = deepSignal(rawData, getPulling());
-      const computedData = new Computed(() => itemExp(arrSignal.get()[getKey ? data[indexName] : i]));
-      const cells = data[Keys.Meta].cells;
-      for (let i = 0; i < vars.length; i++) {
-        const name = vars[i];
-        rawData[name] = undefined;
-        cells.set(name, new 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 Effect(() => {
-        const res = value();
-        this.setProp(node, key, res, hookI);
-      });
-    } else if (valueIsMapKey) {
-      new 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 Store;
-    if (isCC) {
-      Component = ComponentOrRender;
-      child = Component.new();
-    } else {
-      render = ComponentOrRender;
-      const boundStore = render.boundStore;
-      child = deepSignal({}, 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[Keys.Raw][key] = value;
-      } else if (valueIsMapKey) {
-        shareSignal(data, value, child, key);
-      } else {
-        const meta = child[Keys.Meta];
-        const cells = meta.cells;
-        if (typeof value === 'function') {
-          const computed = new Computed(value);
-          cells.set(key, computed);
-          child[Keys.Raw][key] = undefined;
-        } else {
-          cells.set(key, {
-            get: () => value
-          });
-          child[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[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) {
-          runWithPulling(() => data[value], null);
-          const cells = data[Keys.Meta].cells;
-          signal = cells.get(value);
-        } else {
-          const fn = this.getFn(data, value);
-          signal = new Computed(fn);
-        }
-        break;
-      case 'else':
-        if (noCond) {
-          signal = new 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 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 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 = 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[Keys.Raw][value];
-        const isFn = typeof rawVal === 'function';
-        if (hookType === 'dynamic') {
-          const valueIsMapKey = Reflect.has(data[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 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 = 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) {
+            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) {
+              setPulling(parentLogic.effect);
+            } else {
+              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[Keys.Raw], value);
+        const val = data[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(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[Keys.Meta].cells;
+    const hasArrExpKey = Reflect.has(data[Keys.Raw], arrExp);
+    const arrSignal = hasArrExpKey ? (data[arrExp], cells.get(arrExp)) : new 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 Effect(() => {
+      let arr = arrSignal.get();
+      arr[Keys.Iterator];
+      const prevCtx = getPulling();
+      setPulling(null);
+      forNode.arr = arr = 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 (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' && 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;
+      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;
+    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 Scope(() => {});
+    scope.scope = null;
+    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 = deepSignal(indexName ? {
+        [itemExp]: arr[i],
+        [indexName]: i
+      } : {
+        [itemExp]: arr[i]
+      }, getPulling());
+    } else {
+      indexName = indexName ?? KEY_INDEX;
+      const rawData = {
+        [indexName]: i
+      };
+      data = deepSignal(rawData, getPulling());
+      const computedData = new Computed(() => itemExp(arrSignal.get()[getKey ? data[indexName] : i]));
+      const cells = data[Keys.Meta].cells;
+      for (let i = 0; i < vars.length; i++) {
+        const name = vars[i];
+        rawData[name] = undefined;
+        cells.set(name, new 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 Effect(() => {
+        const res = value();
+        this.setProp(node, key, res, hookI);
+      });
+    } else if (valueIsMapKey) {
+      new 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 Store;
+    if (isCC) {
+      Component = ComponentOrRender;
+      child = Component.new();
+    } else {
+      render = ComponentOrRender;
+      const boundStore = render.boundStore;
+      child = deepSignal({}, 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[Keys.Raw][key] = value;
+      } else if (valueIsMapKey) {
+        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[Keys.Meta];
+        const cells = meta.cells;
+        if (typeof value === 'function') {
+          const computed = new Computed(value);
+          cells.set(key, computed);
+          child[Keys.Raw][key] = undefined;
+        } else {
+          cells.set(key, {
+            get: () => value
+          });
+          child[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[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) {
+          runWithPulling(() => data[value], null);
+          const cells = data[Keys.Meta].cells;
+          signal = cells.get(value);
+        } else {
+          const fn = this.getFn(data, value);
+          signal = new Computed(fn);
         }
-        this.dentStack.pop();
-        if (!this.token) {
-          this.setToken(TokenType.Dedent, String(expLen));
+        break;
+      case 'else':
+        if (noCond) {
+          signal = new 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 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 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 = 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' || !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[Keys.Raw][value];
+        const isFn = typeof rawVal === 'function';
+        if (hookType === 'dynamic') {
+          const valueIsMapKey = Reflect.has(data[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 (!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) {
@@ -1564,5 +1991,5 @@ function customRender(option) {
   };
 }
 
-export { bobe, customRender };
+export { Compiler, NodeType, Tokenizer, bobe, customRender };
 //# sourceMappingURL=bobe.esm.js.map