bobe 0.0.31 → 0.0.33

package/dist/bobe.compiler.cjs.js

@@ -0,0 +1,2049 @@
+'use strict';
+
+var bobeShared = require('bobe-shared');
+var aoye = require('aoye');
+
+let TokenType = function (TokenType) {
+  TokenType[TokenType["NewLine"] = 1] = "NewLine";
+  TokenType[TokenType["Indent"] = 2] = "Indent";
+  TokenType[TokenType["Dedent"] = 4] = "Dedent";
+  TokenType[TokenType["Identifier"] = 8] = "Identifier";
+  TokenType[TokenType["Assign"] = 16] = "Assign";
+  TokenType[TokenType["Pipe"] = 32] = "Pipe";
+  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) {
+  FakeType[FakeType["If"] = 1] = "If";
+  FakeType[FakeType["Fail"] = 2] = "Fail";
+  FakeType[FakeType["Else"] = 4] = "Else";
+  FakeType[FakeType["For"] = 8] = "For";
+  FakeType[FakeType["Component"] = 16] = "Component";
+  FakeType[FakeType["Fragment"] = 32] = "Fragment";
+  FakeType[FakeType["ForItem"] = 64] = "ForItem";
+  return FakeType;
+}({});
+const CondBit = FakeType.If | FakeType.Fail | FakeType.Else;
+const LogicalBit = FakeType.If | FakeType.Fail | FakeType.Else | FakeType.For | FakeType.ForItem;
+FakeType.If | FakeType.Fail | FakeType.Else | FakeType.For | FakeType.ForItem | FakeType.Component | FakeType.Fragment;
+const TokenizerSwitcherBit = FakeType.Component | FakeType.Fragment;
+let NodeSort = function (NodeSort) {
+  NodeSort[NodeSort["Logic"] = 1] = "Logic";
+  NodeSort[NodeSort["Real"] = 2] = "Real";
+  NodeSort[NodeSort["Component"] = 4] = "Component";
+  NodeSort[NodeSort["CtxProvider"] = 8] = "CtxProvider";
+  NodeSort[NodeSort["TokenizerSwitcher"] = 16] = "TokenizerSwitcher";
+  return NodeSort;
+}({});
+(function (TerpEvt) {
+  TerpEvt["AllAttrGot"] = "all-attr-got";
+  TerpEvt["HandledComponentNode"] = "handled-component-node";
+  return TerpEvt;
+})({});
+
+class Tokenizer {
+  TabSize = 2;
+  Tab = Array.from({
+    length: this.TabSize
+  }, () => ' ').join('');
+  static EofId = `__EOF__${Date.now()}`;
+  static DedentId = `__DEDENT__${Date.now()}`;
+  needIndent = false;
+  isFirstToken = true;
+  dentStack = [0];
+  i = 0;
+  line = 0;
+  column = 0;
+  preCol = 0;
+  preI = 0;
+  needLoc = false;
+  handledTokens = [];
+  waitingTokens = new bobeShared.Queue();
+  source = '';
+  constructor(hook, useDedentAsEof) {
+    this.hook = hook;
+    this.useDedentAsEof = useDedentAsEof;
+    if (useDedentAsEof) {
+      this.setToken(TokenType.Indent, '');
+      this.isFirstToken = true;
+    }
+  }
+  next() {
+    {
+      const char = this.code[this.i];
+      if (char === '\n') {
+        this.line++;
+        this.column = 0;
+      } else {
+        this.column++;
+      }
+    }
+    this.i++;
+  }
+  getCurrentPos() {
+    return {
+      offset: this.i,
+      line: this.line,
+      column: this.column
+    };
+  }
+  resume(_snapshot) {
+    this.token = undefined;
+    this.needIndent = false;
+    this.isFirstToken = true;
+    this.dentStack = [0];
+    Object.assign(this, _snapshot);
+  }
+  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();
+        }
+      }
+    }
+    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.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 {
+        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;
+      }
+    }
+    if (!this.token) {
+      this.nextToken();
+    }
+    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,
+      loc: this.needLoc ? {
+        start: {
+          offset: this.preI,
+          line: this.line,
+          column: this.preCol
+        },
+        end: {
+          offset: this.i + 1,
+          line: this.line,
+          column: this.column + 1
+        },
+        source: this.code.slice(this.preI, this.i + 1)
+      } : null
+    };
+    this.isFirstToken = false;
+  }
+  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;
+      }
+      outer: while (1) {
+        if (this.needIndent) {
+          this.dent();
+        } 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 ';':
+              this.setToken(TokenType.Semicolon, ';');
+              break;
+            default:
+              if (true) {
+                this.preI = this.i;
+                this.preCol = this.column;
+                this.needLoc = true;
+              }
+              switch (char) {
+                case "'":
+                case '"':
+                  this.str(char);
+                  break;
+                case '{':
+                  const braceToken = this.brace();
+                  this.setToken(TokenType.InsertionExp, braceToken);
+                  break;
+                case '$':
+                  const handled = this.staticIns();
+                  if (handled) break;
+                default:
+                  if (bobeShared.isNum(char)) {
+                    this.number(char);
+                    break;
+                  }
+                  if (typeof char === 'string' && bobeShared.matchIdStart2(char, 0)) {
+                    this.identifier(char);
+                  }
+                  break;
+              }
+              if (true) {
+                this.needLoc = false;
+              }
+              break;
+          }
+          this.next();
+        }
+        if (this.token) {
+          break;
+        }
+      }
+      return this.token;
+    } catch (error) {
+      console.error(error);
+      return this.token;
+    } finally {
+      this.handledTokens.push(this.token);
+    }
+  }
+  condExp() {
+    {
+      this.preCol = this.column;
+      this.preI = this.i;
+      this.needLoc = true;
+    }
+    let value = '';
+    this.token = null;
+    try {
+      if (this.code[this.i] === '\n') {
+        this.setToken(TokenType.Identifier, true);
+        return this.token;
+      }
+      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);
+      {
+        this.needLoc = false;
+      }
+    }
+  }
+  jsExp() {
+    {
+      this.preCol = this.column;
+      this.preI = this.i;
+      this.needLoc = true;
+    }
+    this.token = null;
+    let value = '';
+    try {
+      const char = this.code[this.i];
+      if (char === ';' || char === '\n') {
+        this.setToken(TokenType.Identifier, value);
+        return this.token;
+      }
+      let nextC = this.code[this.i + 1];
+      while (nextC !== ';' && nextC !== '\n') {
+        value += this.code[this.i];
+        this.next();
+        nextC = this.code[this.i + 1];
+      }
+      value += this.code[this.i];
+      this.setToken(TokenType.Identifier, value);
+      return this.token;
+    } finally {
+      this.next();
+      this.handledTokens.push(this.token);
+      {
+        this.needLoc = false;
+      }
+    }
+  }
+  peekChar() {
+    let i = this.i;
+    while (this.code[i] === ' ' || this.code[i] === '\t') {
+      i++;
+    }
+    return this.code[i];
+  }
+  assignment() {
+    this.setToken(TokenType.Assign, '=');
+  }
+  pipe() {
+    this.setToken(TokenType.Pipe, '|');
+  }
+  staticIns() {
+    let nextC = this.code[this.i + 1];
+    if (nextC !== '{') {
+      return false;
+    }
+    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--;
+      }
+    }
+    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
+    };
+  }
+  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;
+        }
+        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
+          });
+        }
+      }
+      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);
+        }
+      } 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;
+  }
+  identifier(char) {
+    let value = char;
+    let nextC;
+    while (1) {
+      nextC = this.code[this.i + 1];
+      if (typeof nextC !== 'string' || !bobeShared.matchIdStart2(nextC, 0)) {
+        break;
+      }
+      value += nextC;
+      this.next();
+    }
+    if (value === Tokenizer.EofId && this.useDedentAsEof) {
+      this.setToken(TokenType.Dedent, '');
+      return;
+    }
+    let realValue = value === 'null' ? null : value === 'undefined' ? undefined : value === 'false' ? false : value === 'true' ? true : value;
+    this.setToken(TokenType.Identifier, realValue);
+  }
+  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);
+  }
+  number(char) {
+    let value = char;
+    let nextC;
+    while (1) {
+      nextC = this.code[this.i + 1];
+      if (!bobeShared.isNum(nextC)) {
+        break;
+      }
+      value += nextC;
+      this.next();
+    }
+    this.setToken(TokenType.Identifier, Number(value));
+  }
+  eof() {
+    this.setToken(TokenType.Eof, 'End Of File');
+  }
+  HookId = '_h_o_o_k_';
+  hookI = 0;
+  _hook = props => {
+    const value = this.token.value;
+    const isDynamicHook = this.token.type & TokenType.InsertionExp;
+    let isStaticHook;
+    {
+      isStaticHook = Boolean(this.token.type & TokenType.StaticInsExp);
+    }
+    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 {
+      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]);
+    }
+  }
+}
+
+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;
+    };
+  }
+  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);
+      };
+    }
+    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;
+      }
+    }
+    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;
+  }
+  function w(e) {
+    return m(e, d, {
+      configurable: true,
+      enumerable: true,
+      value: a
+    });
+  }
+  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;
+  }
+}
+
+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);
+      }
+    }
+    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
+      }
+    };
+  }
+  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);
+        }
+      }
+      if (this.tokenizer.token.type & TokenType.Dedent) {
+        this.tokenizer.nextToken();
+      }
+    }
+    return children;
+  }
+  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();
+  }
+  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();
+      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();
+    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;
+  }
+  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;
+  }
+  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;
+  }
+}
+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;
+  }
+  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];
+  }
+  peekByType(cat) {
+    return this.typeTops[cat]?.value;
+  }
+  peekType() {
+    return this.stack.at(-1).types;
+  }
+  peek() {
+    return this.stack.at(-1).value;
+  }
+}
+
+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++;
+  }
+  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++;
+  }
+  let length = candyLast.length;
+  for (let j = length - 1; j > 0; j--) {
+    const prev = toPrev[candyLast[j]];
+    candyLast[j - 1] = prev;
+  }
+  return candyLast;
+}
+
+const KEY_INDEX = '__BOBE_KEY_INDEX';
+
+const _excluded = ["dentStack", "isFirstToken"];
+class Interpreter {
+  constructor(tokenizer) {
+    this.tokenizer = tokenizer;
+  }
+  isLogicNode(node) {
+    return node && node.__logicType & LogicalBit;
+  }
+  rootComponent = null;
+  program(root, componentNode, before, ctxProvider) {
+    this.rootComponent = componentNode;
+    this.tokenizer.nextToken();
+    const stack = new MultiTypeStack();
+    stack.push({
+      node: root,
+      prev: null
+    }, NodeSort.Real);
+    stack.push({
+      node: componentNode,
+      prev: null
+    }, NodeSort.Component | NodeSort.CtxProvider | NodeSort.TokenizerSwitcher);
+    if (ctxProvider) {
+      stack.push({
+        node: ctxProvider,
+        prev: null
+      }, (ctxProvider.__logicType & LogicalBit ? NodeSort.Logic : 0) | NodeSort.CtxProvider);
+    }
+    const rootLen = stack.length;
+    const ctx = this.ctx = {
+      realParent: root,
+      prevSibling: before,
+      current: null,
+      stack,
+      before
+    };
+    const rootPulling = aoye.getPulling();
+    while (1) {
+      if (this.tokenizer.isEof()) {
+        if (!ctx.prevSibling) ctx.prevSibling = before;
+        this.handleInsert(root, ctx.current, ctx.prevSibling, componentNode);
+        break;
+      }
+      const token = this.tokenizer.token;
+      if (token.type & TokenType.Indent) {
+        this.tokenizer.nextToken();
+        const isLogicNode = this.isLogicNode(ctx.current);
+        stack.push({
+          node: ctx.current,
+          prev: ctx.prevSibling
+        }, !ctx.current.__logicType ? NodeSort.Real : (ctx.current.__logicType & LogicalBit ? NodeSort.Logic : 0) | (ctx.current.__logicType & TokenizerSwitcherBit ? NodeSort.TokenizerSwitcher : 0) | (ctx.current.__logicType === FakeType.Component ? NodeSort.Component : 0) | NodeSort.CtxProvider);
+        if (ctx.current.__logicType) {
+          if (isLogicNode) {
+            aoye.setPulling(ctx.current.effect);
+            if (ctx.current.__logicType & FakeType.ForItem) {
+              ctx.prevSibling = ctx.current.realBefore;
+            }
+          }
+        } else {
+          if (ctx.current) {
+            ctx.realParent = ctx.current;
+          }
+          ctx.prevSibling = null;
+        }
+        ctx.current = this.declaration(ctx);
+        continue;
+      }
+      if (ctx.current) {
+        if (stack.length === rootLen && !ctx.prevSibling) {
+          ctx.prevSibling = before;
+        }
+        this.handleInsert(ctx.realParent, ctx.current, ctx.prevSibling);
+      }
+      if (this.tokenizer.token.type & TokenType.Dedent) {
+        this.tokenizer.nextToken();
+        const _stack$pop = stack.pop(),
+          _stack$pop2 = _slicedToArray(_stack$pop, 2),
+          _stack$pop2$ = _stack$pop2[0],
+          parent = _stack$pop2$.node,
+          prev = _stack$pop2$.prev,
+          sort = _stack$pop2[1];
+        if (!parent.__logicType) {
+          const prevSameType = stack.peekByType(NodeSort.Real);
+          ctx.realParent = prevSameType?.node || root;
+        } else {
+          if (sort & NodeSort.Logic) {
+            const parentLogic = stack.peekByType(NodeSort.Logic)?.node;
+            if (parentLogic) {
+              aoye.setPulling(parentLogic.effect);
+            } else {
+              aoye.setPulling(rootPulling);
+            }
+          }
+          if (sort & NodeSort.TokenizerSwitcher) {
+            const switcher = stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
+            this.tokenizer = switcher.tokenizer;
+          }
+          if (parent.__logicType === FakeType.ForItem) {
+            const _ref = parent,
+              forNode = _ref.forNode;
+            const i = forNode.i,
+              arr = forNode.arr,
+              snapshot = forNode.snapshot;
+            if (i + 1 < arr.length) {
+              this.tokenizer.resume(snapshot);
+              this.tokenizer.nextToken();
+              this.tokenizer.nextToken();
+              ctx.current = forNode.children[++forNode.i];
+              ctx.prevSibling = ctx.current.realBefore;
+              continue;
+            }
+            ctx.prevSibling = forNode.prevSibling;
+            ctx.current = forNode;
+            continue;
+          }
+        }
+        ctx.prevSibling = prev;
+        ctx.current = parent;
+      } else {
+        ctx.prevSibling = ctx.current || ctx.prevSibling;
+        ctx.current = this.declaration(ctx);
+      }
+    }
+    return componentNode;
+  }
+  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);
+      }
+    } else {
+      const childCmp = child;
+      childCmp.realParent = parent;
+      if (prev?.__logicType) {
+        childCmp.realBefore = prev.forNode ? prev.forNode.realAfter : prev.realAfter;
+      } else {
+        childCmp.realBefore = prev;
+      }
+    }
+  }
+  getPrevRealSibling(prevSibling) {
+    if (!prevSibling || !prevSibling.__logicType) {
+      return prevSibling;
+    }
+    let point = prevSibling;
+    while (point != null) {
+      if (point.lastChild) {
+        return point.lastChild.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 {
+        const valueIsMapKey = Reflect.has(data[aoye.Keys.Raw], value);
+        const val = data[aoye.Keys.Raw][value];
+        if (typeof val === 'function') {
+          _node = this.componentOrFragmentDeclaration(val, ctx);
+        } else {
+          const str = valueIsMapKey ? value : this.getFn(data, value);
+          _node = this.createNode('text');
+          this.onePropParsed(data, _node, 'text', str, valueIsMapKey, false);
+        }
+      }
+    } else {
+      _node = this.createNode(value);
+    }
+    this.tokenizer.nextToken();
+    this.headerLine(_node);
+    this.extensionLines(_node);
+    if (_node.__logicType & TokenizerSwitcherBit) {
+      this.onePropParsed = this.oneRealPropParsed;
+      this.tokenizer = _node.tokenizer;
+    }
+    return _node;
+  }
+  forDeclaration() {
+    const arrExp = this.tokenizer.nextToken().value;
+    this.tokenizer.nextToken();
+    const itemToken = this.tokenizer.nextToken();
+    const isDestruct = itemToken.type === TokenType.InsertionExp;
+    let itemExp = itemToken.value,
+      vars;
+    if (isDestruct) {
+      itemExp = '{' + itemExp + '}';
+      vars = itemExp.match(bobeShared.jsVarRegexp);
+      const varStr = vars.join(',');
+      itemExp = new Function(itemExp, `return {${varStr}};`);
+    }
+    let indexName,
+      keyExp,
+      char = this.tokenizer.peekChar();
+    if (char === ';') {
+      this.tokenizer.nextToken();
+      if (this.tokenizer.peekChar() !== '\n') keyExp = this.tokenizer.jsExp().value;
+    } else if (char === '\n') ; else {
+      indexName = this.tokenizer.nextToken().value;
+      if (this.tokenizer.peekChar() === ';') {
+        this.tokenizer.nextToken();
+        if (this.tokenizer.peekChar() !== '\n') keyExp = this.tokenizer.jsExp().value;
+      }
+    }
+    const owner = this.ctx.stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
+    const prevSibling = this.ctx.prevSibling;
+    const forNode = {
+      __logicType: FakeType.For,
+      snapshot: this.tokenizer.snapshot(['dentStack', 'isFirstToken']),
+      realParent: this.ctx.realParent,
+      prevSibling,
+      realBefore: prevSibling?.realAfter || prevSibling,
+      realAfter: null,
+      arr: null,
+      arrSignal: null,
+      itemExp,
+      indexName,
+      getKey: null,
+      children: [],
+      effect: null,
+      owner,
+      vars,
+      i: 0
+    };
+    if (keyExp) {
+      forNode.getKey = new Function('data', `let v;with(data){v=${keyExp}};return v;`);
+    }
+    window['for1'] = forNode;
+    const data = this.getData();
+    const cells = data[aoye.Keys.Meta].cells;
+    const hasArrExpKey = Reflect.has(data[aoye.Keys.Raw], arrExp);
+    const arrSignal = hasArrExpKey ? (data[arrExp], cells.get(arrExp)) : new aoye.Computed(this.getFn(data, arrExp));
+    forNode.arrSignal = arrSignal;
+    forNode.realAfter = this.insertAfterAnchor('for-after');
+    const _forNode$snapshot = forNode.snapshot;
+      _forNode$snapshot.dentStack;
+      _forNode$snapshot.isFirstToken;
+      const snapshotForUpdate = _objectWithoutProperties(_forNode$snapshot, _excluded);
+    let isFirstRender = true;
+    forNode.effect = new aoye.Effect(() => {
+      let arr = arrSignal.get();
+      arr[aoye.Keys.Iterator];
+      const prevCtx = aoye.getPulling();
+      aoye.setPulling(null);
+      forNode.arr = arr = aoye.toRaw(arr);
+      const children = forNode.children;
+      if (isFirstRender) {
+        const len = arr.length;
+        for (let i = len; i--;) {
+          const item = this.createForItem(forNode, i, data);
+          item.realAfter = this.insertAfterAnchor('for-item-after');
+          item.realBefore = this.insertAfterAnchor('for-item-before');
+          item.realParent = forNode.realParent;
+          children[i] = item;
+        }
+        const firstInsert = children[0];
+        if (firstInsert) {
+          this.tokenizer.nextToken();
+          this.tokenizer.nextToken();
+        } else {
+          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;
+            }
+          }
+          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[s - 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);
+              }
+            }
+          }
+        }
+        forNode.children = newChildren;
+      }
+      isFirstRender = false;
+      aoye.setPulling(prevCtx);
+      return isDestroy => {
+        if (isDestroy) {
+          for (let i = 0; i < forNode.children.length; i++) {
+            const item = forNode.children[i];
+            item.effect.dispose();
+          }
+        }
+      };
+    });
+    return forNode.children[0] || forNode;
+  }
+  insertForItem(forNode, i, parentData, newChildren, before, snapshotForUpdate) {
+    const item = this.createForItem(forNode, i, parentData);
+    newChildren[i] = item;
+    let realAfter = this.createAnchor('for-item-after');
+    this.handleInsert(forNode.realParent, realAfter, before);
+    let realBefore = this.createAnchor('for-item-before');
+    this.handleInsert(forNode.realParent, realBefore, before);
+    item.realBefore = realBefore;
+    item.realAfter = realAfter;
+    this.tokenizer = forNode.owner.tokenizer;
+    this.tokenizer.resume(snapshotForUpdate);
+    this.tokenizer.useDedentAsEof = false;
+    aoye.runWithPulling(() => {
+      this.program(forNode.realParent, forNode.owner, realBefore, item);
+    }, item.effect);
+  }
+  removeForItem(children, i) {
+    const child = children[i];
+    this.removeLogicNode(child);
+    this.remove(child.realBefore);
+    this.remove(child.realAfter);
+    child.effect.dispose();
+  }
+  reuseForItem(child, data, itemExp, i, indexName) {
+    if (typeof itemExp === 'string') {
+      child.data[itemExp] = data;
+      if (indexName) {
+        child.data[indexName] = i;
+      }
+    } else {
+      indexName = indexName || KEY_INDEX;
+      child.data[indexName] = i;
+    }
+  }
+  forItemId = 0;
+  createForItem(forNode, i, parentData) {
+    let forItemNode;
+    let data;
+    const scope = new aoye.Scope(() => {});
+    scope.scope = null;
+    aoye.runWithPulling(() => {
+      scope.get();
+    }, null);
+    data = this.getItemData(forNode, i, parentData);
+    forItemNode = {
+      id: this.forItemId++,
+      __logicType: FakeType.ForItem,
+      realParent: null,
+      realBefore: null,
+      realAfter: null,
+      forNode,
+      key: forNode.getKey?.(data),
+      effect: null,
+      data
+    };
+    forItemNode.effect = scope;
+    return forItemNode;
+  }
+  getItemData(forNode, i, parentData) {
+    const arr = forNode.arr,
+      itemExp = forNode.itemExp,
+      vars = forNode.vars,
+      arrSignal = forNode.arrSignal,
+      getKey = forNode.getKey;
+    let indexName = forNode.indexName;
+    let data;
+    if (typeof itemExp === 'string') {
+      data = aoye.deepSignal(indexName ? {
+        [itemExp]: arr[i],
+        [indexName]: i
+      } : {
+        [itemExp]: arr[i]
+      }, aoye.getPulling());
+    } else {
+      indexName = indexName ?? KEY_INDEX;
+      const rawData = {
+        [indexName]: i
+      };
+      data = aoye.deepSignal(rawData, aoye.getPulling());
+      const computedData = new aoye.Computed(() => itemExp(arrSignal.get()[getKey ? data[indexName] : i]));
+      const cells = data[aoye.Keys.Meta].cells;
+      for (let i = 0; i < vars.length; i++) {
+        const name = vars[i];
+        rawData[name] = undefined;
+        cells.set(name, new aoye.Computed(() => computedData.get()[name]));
+      }
+    }
+    Object.setPrototypeOf(data, parentData);
+    return data;
+  }
+  getData() {
+    const _this$ctx$stack$peekB = this.ctx.stack.peekByType(NodeSort.CtxProvider),
+      node = _this$ctx$stack$peekB.node;
+    return node.data;
+  }
+  onePropParsed(data, node, key, value, valueIsMapKey, isFn, hookI) {
+    if (isFn) {
+      this.setProp(node, key, value, hookI);
+    } else if (typeof value === 'function') {
+      new aoye.Effect(() => {
+        const res = value();
+        this.setProp(node, key, res, hookI);
+      });
+    } else if (valueIsMapKey) {
+      new aoye.Effect(() => {
+        const res = data[value];
+        this.setProp(node, key, res, hookI);
+      });
+    } else {
+      this.setProp(node, key, value, hookI);
+    }
+  }
+  oneRealPropParsed = this.onePropParsed.bind(this);
+  componentOrFragmentDeclaration(ComponentOrRender, ctx) {
+    let Component, render, child;
+    const isCC = ComponentOrRender.prototype instanceof aoye.Store;
+    if (isCC) {
+      Component = ComponentOrRender;
+      child = Component.new();
+    } else {
+      render = ComponentOrRender;
+      const boundStore = render.boundStore;
+      child = aoye.deepSignal({}, aoye.getPulling(), true);
+      Object.setPrototypeOf(child, boundStore);
+    }
+    const node = {
+      __logicType: isCC ? FakeType.Component : FakeType.Fragment,
+      realParent: ctx.realParent,
+      realBefore: null,
+      realAfter: null,
+      data: child,
+      tokenizer: render ? render(true) : child['ui'](true)
+    };
+    this.onePropParsed = (data, _, key, value, valueIsMapKey, isFn, hookI) => {
+      if (isFn) {
+        child[aoye.Keys.Raw][key] = value;
+      } else if (valueIsMapKey) {
+        aoye.shareSignal(data, value, child, key);
+      } else {
+        const meta = child[aoye.Keys.Meta];
+        const cells = meta.cells;
+        if (typeof value === 'function') {
+          const computed = new aoye.Computed(value);
+          cells.set(key, computed);
+          child[aoye.Keys.Raw][key] = undefined;
+        } else {
+          cells.set(key, {
+            get: () => value
+          });
+          child[aoye.Keys.Raw][key] = value;
+        }
+      }
+    };
+    node.realAfter = this.insertAfterAnchor('component-after');
+    return node;
+  }
+  getFn(data, expression) {
+    return new Function('data', `let v;with(data){v=${expression}};return v;`).bind(undefined, data);
+  }
+  condDeclaration(ctx) {
+    const prevSibling = ctx.prevSibling;
+    const keyWord = this.tokenizer.token;
+    const expToken = this.tokenizer.condExp();
+    const value = expToken.value;
+    const isElse = keyWord.value === 'else';
+    const isIf = keyWord.value === 'if';
+    const preIsCond = prevSibling?.__logicType & CondBit;
+    const data = this.getData();
+    const noCond = value === true;
+    const valueIsMapKey = !noCond && Reflect.has(data[aoye.Keys.Raw], value);
+    const owner = ctx.stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
+    const ifNode = {
+      __logicType: isElse ? FakeType.Else : isIf ? FakeType.If : FakeType.Fail,
+      snapshot: this.tokenizer.snapshot(),
+      realParent: null,
+      realBefore: null,
+      realAfter: null,
+      condition: null,
+      preCond: preIsCond ? prevSibling : null,
+      isFirstRender: true,
+      effect: null,
+      owner,
+      data
+    };
+    let signal;
+    switch (keyWord.value) {
+      case 'if':
+        if (valueIsMapKey) {
+          aoye.runWithPulling(() => data[value], null);
+          const cells = data[aoye.Keys.Meta].cells;
+          signal = cells.get(value);
+        } else {
+          const fn = this.getFn(data, value);
+          signal = new aoye.Computed(fn);
+        }
+        break;
+      case 'else':
+        if (noCond) {
+          signal = new aoye.Computed(() => {
+            let point = ifNode.preCond;
+            while (point) {
+              if (point.condition.get()) {
+                return false;
+              }
+              if (point.__logicType === FakeType.If) {
+                break;
+              }
+              point = point.preCond;
+            }
+            return true;
+          });
+        } else {
+          const fn = valueIsMapKey ? null : this.getFn(data, value);
+          signal = new aoye.Computed(() => {
+            let point = ifNode.preCond;
+            while (point) {
+              if (point.condition.get()) {
+                return false;
+              }
+              if (point.__logicType === FakeType.If) {
+                break;
+              }
+              point = point.preCond;
+            }
+            return valueIsMapKey ? data[value] : fn();
+          });
+        }
+        break;
+      case 'fail':
+        signal = new aoye.Computed(() => {
+          let point = ifNode.preCond;
+          while (point) {
+            if (point.condition.get()) {
+              return false;
+            }
+            point = point.preCond;
+          }
+          return true;
+        });
+        break;
+    }
+    ifNode.condition = signal;
+    ifNode.realAfter = this.insertAfterAnchor(`${keyWord.value}-after`);
+    const ef = aoye.effect(({
+      val
+    }) => {
+      if (val) {
+        if (ifNode.isFirstRender) {
+          this.tokenizer.nextToken();
+          this.tokenizer.nextToken();
+        } else {
+          this.tokenizer = ifNode.owner.tokenizer;
+          this.tokenizer.resume(ifNode.snapshot);
+          this.tokenizer.useDedentAsEof = false;
+          this.program(ifNode.realParent, ifNode.owner, ifNode.realBefore, ifNode);
+        }
+      } else {
+        if (ifNode.isFirstRender) {
+          this.tokenizer.skip();
+        } else {
+          this.removeLogicNode(ifNode);
+        }
+      }
+      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;
+    }
+  }
+  extensionLines(_node) {
+    while (1) {
+      if ((this.tokenizer.token.type & TokenType.Pipe) === 0) {
+        return;
+      }
+      this.tokenizer.nextToken();
+      this.attributeList(_node);
+      if ((this.tokenizer.token.type & TokenType.NewLine) === 0) {
+        return;
+      }
+      this.tokenizer.nextToken();
+    }
+  }
+  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 {
+        const _this$tokenizer$_hook3 = this.tokenizer._hook({}),
+          _this$tokenizer$_hook4 = _slicedToArray(_this$tokenizer$_hook3, 3),
+          hookType = _this$tokenizer$_hook4[0],
+          value = _this$tokenizer$_hook4[1],
+          hookI = _this$tokenizer$_hook4[2];
+        const rawVal = data[aoye.Keys.Raw][value];
+        const isFn = typeof rawVal === 'function';
+        if (hookType === 'dynamic') {
+          const valueIsMapKey = Reflect.has(data[aoye.Keys.Raw], value);
+          const fn = isFn ? rawVal : valueIsMapKey ? value : this.getFn(data, value);
+          this.onePropParsed(data, _node, key, fn, valueIsMapKey, isFn, hookI);
+        } else if (hookType === 'static') {
+          this.onePropParsed(data, _node, key, value, false, isFn, hookI);
+        } else {
+          this.onePropParsed(data, _node, key, value, false, isFn, hookI);
+        }
+        key = null;
+        eq = null;
+      }
+      this.tokenizer.nextToken();
+    }
+  }
+  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;
+    }
+  }
+  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;
+    }
+  }
+  setProp(node, key, value, hookI) {
+    node.props[key] = value;
+  }
+}
+
+function bobe(fragments, ...values) {
+  const ui = function ui(isSub) {
+    const tokenizer = new Tokenizer(({
+      i
+    }) => {
+      return values[i];
+    }, isSub);
+    tokenizer.init(Array.from(fragments));
+    return tokenizer;
+  };
+  ui.boundStore = aoye.Store.Current;
+  return ui;
+}
+function customRender(option) {
+  return function render(Ctor, root) {
+    const store = Ctor.new();
+    const tokenizer = store['ui'](false);
+    const terp = new Interpreter(tokenizer);
+    terp.config(option);
+    const componentNode = {
+      __logicType: FakeType.Component,
+      realParent: root,
+      data: store,
+      tokenizer
+    };
+    terp.program(root, componentNode);
+    return [componentNode, store];
+  };
+}
+
+exports.Compiler = Compiler;
+exports.NodeType = NodeType;
+exports.Tokenizer = Tokenizer;
+exports.bobe = bobe;
+exports.customRender = customRender;
+Object.keys(aoye).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return aoye[k]; }
+  });
+});
+//# sourceMappingURL=bobe.compiler.cjs.js.map