securemark 0.289.1 → 0.289.3

package/src/combinator/control/manipulation/fallback.ts

@@ -1,7 +1,7 @@
-import { Parser, Tree, Context } from '../../data/parser';
+import { Parser, Node, Context } from '../../data/parser';
 import { union } from '../../data/parser/union';
 
-export function fallback<P extends Parser<unknown>>(parser: P, otherwise: Parser<Tree<P>, Context<P>>): P;
-export function fallback<T>(parser: Parser<T>, otherwise: Parser<T>): Parser<T> {
+export function fallback<P extends Parser<unknown>>(parser: P, otherwise: Parser<Node<P>, Context<P>>): P;
+export function fallback<N>(parser: Parser<N>, otherwise: Parser<N>): Parser<N> {
   return union([parser, otherwise]);
 }

package/src/combinator/control/manipulation/indent.ts

@@ -9,7 +9,7 @@ import { memoize } from 'spica/memoize';
 
 export function indent<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
 export function indent<P extends Parser<unknown>>(opener: RegExp, parser: P, separation?: boolean): P;
-export function indent<T>(opener: RegExp | Parser<T>, parser?: Parser<T> | boolean, separation = false): Parser<T> {
+export function indent<N>(opener: RegExp | Parser<N>, parser?: Parser<N> | boolean, separation = false): Parser<N> {
   if (typeof opener === 'function') return indent(/^([ \t])\1*/, opener, parser as boolean);
   assert(parser);
   return bind(block(match(
@@ -17,9 +17,9 @@ export function indent<T>(opener: RegExp | Parser<T>, parser?: Parser<T> | boole
     memoize(
     ([indent]) =>
       some(line(open(indent, ({ source }) => [[source], '']))),
-    ([indent]) => indent.length * 2 + +(indent[0] === ' '), {}), false), separation),
+    ([indent]) => indent.length * 2 + +(indent[0] === ' '), {})), separation),
     (lines, rest, context) => {
-      assert(parser = parser as Parser<T>);
+      assert(parser = parser as Parser<N>);
       // 影響する使用はないはず
       //const { backtracks } = context;
       //context.backtracks = {};

package/src/combinator/control/manipulation/lazy.ts

@@ -1,8 +1,8 @@
 import { Parser } from '../../data/parser';
 
 export function lazy<P extends Parser<unknown>>(builder: () => P): P;
-export function lazy<T>(builder: () => Parser<T>): Parser<T> {
-  let parser: Parser<T>;
+export function lazy<N>(builder: () => Parser<N>): Parser<N> {
+  let parser: Parser<N>;
   return input =>
     parser !== undefined
       ? parser(input)

package/src/combinator/control/manipulation/match.ts

@@ -2,7 +2,7 @@ import { Parser, exec, check } from '../../data/parser';
 import { consume } from '../../../combinator';
 
 export function match<P extends Parser<unknown>>(pattern: RegExp, f: (matched: RegExpMatchArray) => P, cost?: boolean): P;
-export function match<T>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<T>, cost = true): Parser<T> {
+export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<N>, cost = false): Parser<N> {
   assert(!pattern.flags.match(/[gmy]/) && pattern.source.startsWith('^'));
   return input => {
     const { source, context } = input;

package/src/combinator/control/manipulation/recovery.ts

@@ -1,7 +1,7 @@
-import { Parser, Input, Result, Tree, Context } from '../../data/parser';
+import { Parser, Input, Result, Node, Context } from '../../data/parser';
 
-export function recover<P extends Parser<unknown>>(parser: P, fallback: (input: Input<Context<P>>, reason: unknown) => Result<Tree<P>>): P;
-export function recover<T>(parser: Parser<T>, fallback: (input: Input, reason: unknown) => Result<T>): Parser<T> {
+export function recover<P extends Parser<unknown>>(parser: P, fallback: (input: Input<Context<P>>, reason: unknown) => Result<Node<P>>): P;
+export function recover<N>(parser: Parser<N>, fallback: (input: Input, reason: unknown) => Result<N>): Parser<N> {
   return input => {
     try {
       return parser(input);

package/src/combinator/control/manipulation/reverse.ts

@@ -2,7 +2,7 @@ import { Parser } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 
 export function reverse<P extends Parser<unknown>>(parser: P): P;
-export function reverse<T>(parser: Parser<T>): Parser<T> {
+export function reverse<N>(parser: Parser<N>): Parser<N> {
   return fmap(parser, nodes => nodes.reverse());
 }
 

package/src/combinator/control/manipulation/scope.ts

@@ -2,7 +2,7 @@ import { Parser, Context, eval, exec, check } from '../../data/parser';
 import { consume } from '../../../combinator';
 
 export function focus<P extends Parser<unknown>>(scope: string | RegExp, parser: P, cost?: boolean): P;
-export function focus<T>(scope: string | RegExp, parser: Parser<T>, cost = true): Parser<T> {
+export function focus<N>(scope: string | RegExp, parser: Parser<N>, cost = true): Parser<N> {
   assert(scope instanceof RegExp ? !scope.flags.match(/[gmy]/) && scope.source.startsWith('^') : scope);
   assert(parser);
   const match: (source: string) => string = typeof scope === 'string'
@@ -29,9 +29,9 @@ export function focus<T>(scope: string | RegExp, parser: Parser<T>, cost = true)
   };
 }
 
-//export function rewrite<T, C extends Ctx, D extends Parser<unknown, C>[]>(scope: Parser<unknown, C, D>, parser: Parser<T, C, never>): Parser<T, C, D>;
+//export function rewrite<N, C extends Ctx, D extends Parser<unknown, C>[]>(scope: Parser<unknown, C, D>, parser: Parser<N, C, never>): Parser<N, C, D>;
 export function rewrite<P extends Parser<unknown>>(scope: Parser<unknown, Context<P>>, parser: P): P;
-export function rewrite<T>(scope: Parser<unknown>, parser: Parser<T>): Parser<T> {
+export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>): Parser<N> {
   assert(scope);
   assert(parser);
   return input => {

package/src/combinator/control/manipulation/surround.ts

@@ -1,47 +1,46 @@
-import { Parser, Input, Result, Ctx, Tree, Context, SubParsers, SubTree, IntermediateParser, eval, exec, check } from '../../data/parser';
-import { fmap } from '../monad/fmap';
+import { Parser, Input, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, exec, check } from '../../data/parser';
 import { unshift, push } from 'spica/array';
 
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: false,
-  f?: (rss: [S[], SubTree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], SubTree<P>[], string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [S[], SubNode<P>[], S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], SubNode<P>[], string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  bstate?: number,
+  backtrackstate?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: boolean,
-  f?: (rss: [S[], SubTree<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], SubTree<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [S[], SubNode<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], SubNode<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  bstate?: number,
+  backtrackstate?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: false,
-  f?: (rss: [S[], Tree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], Tree<P>[], string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [S[], Node<P>[], S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], Node<P>[], string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  bstate?: number,
+  backtrackstate?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: boolean,
-  f?: (rss: [S[], Tree<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], Tree<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [S[], Node<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], Node<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  bstate?: number,
+  backtrackstate?: number,
 ): P;
-export function surround<T>(
-  opener: string | RegExp | Parser<T>, parser: Parser<T>, closer: string | RegExp | Parser<T>,
+export function surround<N>(
+  opener: string | RegExp | Parser<N>, parser: Parser<N>, closer: string | RegExp | Parser<N>,
   optional: boolean = false,
-  f?: (rss: [T[], T[], T[]], rest: string, context: Ctx) => Result<T>,
-  g?: (rss: [T[], T[], string], rest: string, context: Ctx) => Result<T>,
+  f?: (rss: [N[], N[], N[]], rest: string, context: Ctx) => Result<N>,
+  g?: (rss: [N[], N[], string], rest: string, context: Ctx) => Result<N>,
   backtracks: readonly number[] = [],
-  bstate: number = 0,
-): Parser<T> {
+  backtrackstate: number = 0,
+): Parser<N> {
   switch (typeof opener) {
     case 'string':
     case 'object':
@@ -52,61 +51,63 @@ export function surround<T>(
     case 'object':
       closer = match(closer);
   }
+  const statesize = 2;
   return ({ source, context }) => {
-    const lmr_ = source;
-    if (lmr_ === '') return;
+    const sme_ = source;
+    if (sme_ === '') return;
     const { linebreak } = context;
     context.linebreak = undefined;
-    const res1 = opener({ source: lmr_, context });
-    assert(check(lmr_, res1, false));
-    if (res1 === undefined) return void revert(context, linebreak);
-    const rl = eval(res1);
-    const mr_ = exec(res1);
+    const resultS = opener({ source: sme_, context });
+    assert(check(sme_, resultS, false));
+    if (resultS === undefined) return void revert(context, linebreak);
+    const nodesS = eval(resultS);
+    const me_ = exec(resultS);
     for (const backtrack of backtracks) {
       if (backtrack & 1) {
         const { backtracks = {}, backtrack: state = 0, offset = 0 } = context;
-        for (let i = 0; i < source.length - mr_.length; ++i) {
+        for (let i = 0; i < source.length - me_.length; ++i) {
           if (source[i] !== source[0]) break;
-          const pos = source.length + offset - i - 1;
+          const pos = source.length - i + offset - 1;
+          assert(pos >= 0);
           if (!(pos in backtracks)) continue;
-          // bracket only
-          const shift = backtrack >>> 2 === state >>> 2 ? state & 3 : 0;
-          if (backtracks[pos] & 1 << (backtrack >>> 2) + shift) return void revert(context, linebreak);
+          const shift = backtrack >>> statesize & state >>> statesize ? state & (1 << statesize) - 1 : 0;
+          if (backtracks[pos] & 1 << size(backtrack >>> statesize) + shift) return void revert(context, linebreak);
         }
       }
     }
-    const { backtrack: state = 0 } = context;
-    context.backtrack = state | bstate;
-    const res2 = mr_ !== '' ? parser({ source: mr_, context }) : undefined;
-    assert(check(mr_, res2));
-    context.backtrack = state;
-    const rm = eval(res2);
-    const r_ = exec(res2, mr_);
-    if (!rm && !optional) return void revert(context, linebreak);
-    const res3 = closer({ source: r_, context });
-    assert(check(r_, res3, false));
-    const rr = eval(res3);
-    const rest = exec(res3, r_);
-    if (rest.length === lmr_.length) return void revert(context, linebreak);
+    const { backtrack = 0 } = context;
+    context.backtrack = backtrack | backtrackstate;
+    const resultM = me_ !== '' ? parser({ source: me_, context }) : undefined;
+    assert(check(me_, resultM));
+    context.backtrack = backtrack;
+    const nodesM = eval(resultM);
+    const e_ = exec(resultM, me_);
+    if (!nodesM && !optional) return void revert(context, linebreak);
+    const resultE = closer({ source: e_, context });
+    assert(check(e_, resultE, false));
+    const nodesE = eval(resultE);
+    const rest = exec(resultE, e_);
+    if (rest.length === sme_.length) return void revert(context, linebreak);
     for (const backtrack of backtracks) {
-      if (backtrack & 2 && rr === undefined) {
+      if (backtrack & 2 && nodesE === undefined) {
         const { backtracks = {}, backtrack: state = 0, offset = 0 } = context;
-        // bracket only
-        const shift = backtrack >>> 2 === state >>> 2 ? state & 3 : 0;
-        backtracks[source.length + offset - 1] |= 1 << (backtrack >>> 2) + shift;
+        const pos = source.length + offset - 1;
+        assert(pos >= 0);
+        const shift = backtrack >>> statesize & state >>> statesize ? state & (1 << statesize) - 1 : 0;
+        backtracks[pos] |= 1 << size(backtrack >>> statesize) + shift;
       }
     }
     context.recent = [
-      lmr_.slice(0, lmr_.length - mr_.length),
-      mr_.slice(0, mr_.length - r_.length),
-      r_.slice(0, r_.length - rest.length),
+      sme_.slice(0, sme_.length - me_.length),
+      me_.slice(0, me_.length - e_.length),
+      e_.slice(0, e_.length - rest.length),
     ];
-    const result = rr
+    const result = nodesE
       ? f
-        ? f([rl, rm!, rr], rest, context)
-        : [push(unshift(rl, rm ?? []), rr), rest] satisfies [T[], string]
+        ? f([nodesS, nodesM!, nodesE], rest, context)
+        : [push(unshift(nodesS, nodesM ?? []), nodesE), rest] satisfies [N[], string]
       : g
-        ? g([rl, rm!, mr_], rest, context)
+        ? g([nodesS, nodesM!, me_], rest, context)
         : undefined;
     if (result) {
       context.linebreak ??= linebreak;
@@ -117,6 +118,14 @@ export function surround<T>(
     return result;
   };
 }
+export function open<P extends Parser<unknown>>(opener: string | RegExp | Parser<Node<P>, Context<P>>, parser: P, optional?: boolean): P;
+export function open<N>(opener: string | RegExp | Parser<N>, parser: Parser<N>, optional = false): Parser<N> {
+  return surround(opener, parser, '', optional);
+}
+export function close<P extends Parser<unknown>>(parser: P, closer: string | RegExp | Parser<Node<P>, Context<P>>, optional?: boolean): P;
+export function close<N>(parser: Parser<N>, closer: string | RegExp | Parser<N>, optional: boolean = false): Parser<N> {
+  return surround('', parser, closer, optional);
+}
 
 function match(pattern: string | RegExp): (input: Input) => [never[], string] | undefined {
   switch (typeof pattern) {
@@ -131,20 +140,21 @@ function match(pattern: string | RegExp): (input: Input) => [never[], string] |
       };
   }
 }
-
 function revert(context: Ctx, linebreak: number | undefined): void {
   context.linebreak = linebreak;
 }
-
-export function open<P extends Parser<unknown>>(opener: string | RegExp | Parser<Tree<P>, Context<P>>, parser: P, optional?: boolean): P;
-export function open<T>(opener: string | RegExp | Parser<T>, parser: Parser<T>, optional = false): Parser<T> {
-  return surround(opener, parser, '', optional);
-}
-export function close<P extends Parser<unknown>>(parser: P, closer: string | RegExp | Parser<Tree<P>, Context<P>>, optional?: boolean): P;
-export function close<T>(parser: Parser<T>, closer: string | RegExp | Parser<T>, optional: boolean = false): Parser<T> {
-  return surround('', parser, closer, optional);
-}
-
-export function clear<D extends Parser<unknown, C>[], C extends Ctx>(parser: Parser<unknown, C, D>): Parser<never, C, D> {
-  return fmap<never, Parser<unknown, C, D>>(parser, () => []);
+function size(bits: number): number {
+  if (bits === 0) return 0;
+  let p = 0;
+  for (let s = 32 / 2; s > 0; s >>>= 1) {
+    const q = p + s;
+    if (bits >>> q === 0) continue;
+    p = q;
+  }
+  return p + 1;
 }
+assert(size(0 << 0) === 0);
+assert(size(1 << 0) === 1);
+assert(size(1 << 1) === 2);
+assert(size(1 << 30) === 31);
+assert(size(1 << 31) === 32);

package/src/combinator/control/manipulation/trim.ts

@@ -2,16 +2,16 @@ import { Parser } from '../../data/parser';
 import { convert } from './convert';
 
 export function trim<P extends Parser<unknown>>(parser: P): P;
-export function trim<T>(parser: Parser<T>): Parser<T> {
+export function trim<N>(parser: Parser<N>): Parser<N> {
   return convert(source => source.trim(), parser, false);
 }
 
 export function trimStart<P extends Parser<unknown>>(parser: P): P;
-export function trimStart<T>(parser: Parser<T>): Parser<T> {
+export function trimStart<N>(parser: Parser<N>): Parser<N> {
   return convert(source => source.trimStart(), parser, true);
 }
 
 export function trimEnd<P extends Parser<unknown>>(parser: P): P;
-export function trimEnd<T>(parser: Parser<T>): Parser<T> {
+export function trimEnd<N>(parser: Parser<N>): Parser<N> {
   return convert(source => source.trimEnd(), parser, false);
 }

package/src/combinator/control/monad/bind.ts

@@ -1,10 +1,10 @@
-import { Parser, Result, Ctx, Tree, Context, SubParsers, SubTree, IntermediateParser, eval, exec, check } from '../../data/parser';
+import { Parser, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, exec, check } from '../../data/parser';
 
-export function bind<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubTree<P>[], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>): P;
-export function bind<P extends Parser<unknown>>(parser: P, f: (nodes: Tree<P>[], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>): P;
-export function bind<T, P extends Parser<unknown>>(parser: Parser<T, Context<P>, SubParsers<P>>, f: (nodes: T[], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>): P;
-export function bind<U, P extends Parser<unknown>>(parser: P, f: (nodes: Tree<P>[], rest: string, context: Context<P>) => Result<U, Context<P>, SubParsers<P>>): Parser<U, Context<P>, SubParsers<P>>;
-export function bind<T, U>(parser: Parser<T>, f: (nodes: T[], rest: string, context: Ctx) => Result<U>): Parser<U> {
+export function bind<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubNode<P>[], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
+export function bind<P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
+export function bind<N, P extends Parser<unknown>>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: N[], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
+export function bind<U, P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], rest: string, context: Context<P>) => Result<U, Context<P>, SubParsers<P>>): Parser<U, Context<P>, SubParsers<P>>;
+export function bind<N, U>(parser: Parser<N>, f: (nodes: N[], rest: string, context: Ctx) => Result<U>): Parser<U> {
   assert(parser);
   return input => {
     const { source, context } = input;

package/src/combinator/control/monad/fmap.ts

@@ -1,10 +1,10 @@
-import { Parser, Ctx, SubParsers, Tree, Context, IntermediateParser, SubTree } from '../../data/parser';
+import { Parser, Ctx, SubParsers, Node, Context, IntermediateParser, SubNode } from '../../data/parser';
 import { bind } from './bind';
 
-export function fmap<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubTree<P>[], rest: string, context: Context<P>) => Tree<P>[]): P;
-export function fmap<P extends Parser<unknown>>(parser: P, f: (nodes: Tree<P>[], rest: string, context: Context<P>) => Tree<P>[]): P;
-export function fmap<T, P extends Parser<unknown>>(parser: Parser<T, Context<P>, SubParsers<P>>, f: (nodes: T[], rest: string, context: Context<P>) => Tree<P>[]): P;
-export function fmap<U, P extends Parser<unknown>>(parser: P, f: (nodes: Tree<P>[], rest: string, context: Context<P>) => U[]): Parser<U, Context<P>, SubParsers<P>>;
-export function fmap<T, U>(parser: Parser<T>, f: (nodes: T[], rest: string, context: Ctx) => U[]): Parser<U> {
+export function fmap<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubNode<P>[], rest: string, context: Context<P>) => Node<P>[]): P;
+export function fmap<P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], rest: string, context: Context<P>) => Node<P>[]): P;
+export function fmap<N, P extends Parser<unknown>>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: N[], rest: string, context: Context<P>) => Node<P>[]): P;
+export function fmap<U, P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], rest: string, context: Context<P>) => U[]): Parser<U, Context<P>, SubParsers<P>>;
+export function fmap<N, U>(parser: Parser<N>, f: (nodes: N[], rest: string, context: Ctx) => U[]): Parser<U> {
   return bind(parser, (nodes, rest, context) => [f(nodes, rest, context), rest]);
 }

package/src/combinator/data/parser/context/delimiter.ts

@@ -2,6 +2,7 @@ import { Ctx } from '../../parser';
 import { memoize } from 'spica/memoize';
 
 interface Delimiter {
+  readonly memory: Delimiter[];
   readonly index: number;
   readonly signature: string;
   readonly matcher: (source: string) => boolean | undefined;
@@ -11,28 +12,26 @@ interface Delimiter {
 }
 
 export class Delimiters {
-  public static signature(pattern: string | RegExp | undefined): string {
+  public static signature(pattern: string | RegExp | undefined, linebreakable: boolean): string {
     switch (typeof pattern) {
       case 'undefined':
         return `undefined`;
       case 'string':
-        return `s:${pattern}`;
+        return `s:${pattern}:${+linebreakable}`;
       case 'object':
-        return `r/${pattern.source}/${pattern.flags}`;
+        return `r/${pattern.source}/${+linebreakable}`;
+    }
+  }
+  public static matcher(pattern: string | RegExp | undefined): (source: string) => true | undefined {
+    switch (typeof pattern) {
+      case 'undefined':
+        return () => undefined;
+      case 'string':
+        return source => source.slice(0, pattern.length) === pattern || undefined;
+      case 'object':
+        return source => pattern.test(source) || undefined;
     }
   }
-  public static matcher = memoize(
-    (pattern: string | RegExp | undefined): (source: string) => true | undefined => {
-      switch (typeof pattern) {
-        case 'undefined':
-          return () => undefined;
-        case 'string':
-          return source => source.slice(0, pattern.length) === pattern || undefined;
-        case 'object':
-          return source => pattern.test(source) || undefined;
-      }
-    },
-    this.signature);
   private readonly registry = memoize<(signature: string) => Delimiter[]>(() => []);
   private readonly delimiters: Delimiter[] = [];
   private readonly stack: number[] = [];
@@ -52,13 +51,15 @@ export class Delimiters {
       const { signature, matcher, precedence, linebreakable } = delims[i];
       const memory = registry(signature);
       const index = memory[0]?.index ?? delimiters.length;
-      if (memory.length === 0 || precedence > delimiters[index].precedence) {
+      assert(memory.length === 0 || precedence === delimiters[index].precedence);
+      if (memory.length === 0) {
         const delimiter: Delimiter = {
+          memory,
           index,
           signature,
           matcher,
           precedence,
-          linebreakable: linebreakable,
+          linebreakable,
           state: true,
         };
         delimiters[index] = delimiter;
@@ -74,12 +75,12 @@ export class Delimiters {
   }
   public pop(count: number): void {
     assert(count > 0);
-    const { registry, delimiters, stack } = this;
+    const { delimiters, stack } = this;
     for (let i = 0; i < count; ++i) {
       assert(this.stack.length > 0);
       const index = stack.pop()!;
       if (index === -1) continue;
-      const memory = registry(delimiters[index].signature);
+      const { memory } = delimiters[index];
       assert(memory.length > 0);
       if (memory.length === 1) {
         assert(index === delimiters.length - 1);
@@ -88,6 +89,7 @@ export class Delimiters {
         delimiters.pop();
       }
       else {
+        assert(false);
         memory.pop();
         delimiters[index] = memory.at(-1)!;
       }

package/src/combinator/data/parser/context.ts

@@ -1,9 +1,9 @@
 import { ObjectCreate, min } from 'spica/alias';
-import { Parser, Result, Ctx, Tree, Context } from '../../data/parser';
+import { Parser, Result, Ctx, Node, Context } from '../../data/parser';
 import { clone } from 'spica/assign';
 
 export function reset<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
-export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
+export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -13,7 +13,7 @@ export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
 }
 
 export function context<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
-export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
+export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -22,8 +22,8 @@ export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
     apply(parser, source, context, changes, values);
 }
 
-function apply<P extends Parser<unknown>>(parser: P, source: string, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Tree<P>>;
-function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<T> {
+function apply<P extends Parser<unknown>>(parser: P, source: string, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Node<P>>;
+function apply<N>(parser: Parser<N>, source: string, context: Ctx, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<N> {
   if (reset) {
     context.backtracks = {};
   }
@@ -97,7 +97,7 @@ export function recursion(recursion: number, parser: Parser<unknown>): Parser<un
 }
 
 export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
-export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
+export function precedence<N>(precedence: number, parser: Parser<N>): Parser<N> {
   assert(precedence >= 0);
   return input => {
     const { context } = input;
@@ -115,7 +115,7 @@ export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T>
 
 export function state<P extends Parser<unknown>>(state: number, parser: P): P;
 export function state<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
-export function state<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
+export function state<N>(state: number, positive: boolean | Parser<N>, parser?: Parser<N>): Parser<N> {
   if (typeof positive === 'function') {
     parser = positive;
     positive = true;
@@ -136,7 +136,7 @@ export function state<T>(state: number, positive: boolean | Parser<T>, parser?:
 
 export function constraint<P extends Parser<unknown>>(state: number, parser: P): P;
 export function constraint<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
-export function constraint<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
+export function constraint<N>(state: number, positive: boolean | Parser<N>, parser?: Parser<N>): Parser<N> {
   if (typeof positive === 'function') {
     parser = positive;
     positive = true;

package/src/combinator/data/parser/inits.ts

@@ -1,13 +1,13 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function inits<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[], rest: string) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return ({ source, context }) => {
     let rest = source;
-    let nodes: T[] | undefined;
+    let nodes: N[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') break;
       if (context.delimiters?.match(rest, context)) break;

package/src/combinator/data/parser/sequence.ts

@@ -1,13 +1,13 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function sequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[], rest: string) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return ({ source, context }) => {
     let rest = source;
-    let nodes: T[] | undefined;
+    let nodes: N[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') return;
       if (context.delimiters?.match(rest, context)) return;

package/src/combinator/data/parser/some.ts

@@ -6,13 +6,13 @@ type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number,
 
 export function some<P extends Parser<unknown>>(parser: P, limit?: number): P;
 export function some<P extends Parser<unknown>>(parser: P, end?: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
-export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delimiters: readonly DelimiterOption[] = [], limit = -1): Parser<T> {
+export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delimiters: readonly DelimiterOption[] = [], limit = -1): Parser<N> {
   if (typeof end === 'number') return some(parser, undefined, delimiters, end);
   assert(parser);
   assert([end].concat(delimiters.map(o => o[0])).every(d => d instanceof RegExp ? !d.flags.match(/[gmy]/) && d.source.startsWith('^') : true));
   const match = Delimiters.matcher(end);
   const delims = delimiters.map(([delimiter, precedence, linebreakable = true]) => ({
-    signature: Delimiters.signature(delimiter),
+    signature: Delimiters.signature(delimiter, linebreakable),
     matcher: Delimiters.matcher(delimiter),
     precedence,
     linebreakable,
@@ -21,7 +21,7 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
     if (source === '') return;
     assert(context.backtracks ??= {});
     let rest = source;
-    let nodes: T[] | undefined;
+    let nodes: N[] | undefined;
     if (delims.length > 0) {
       context.delimiters ??= new Delimiters();
       context.delimiters.push(delims);

package/src/combinator/data/parser/subsequence.ts

@@ -1,9 +1,9 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
-export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function subsequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[], rest: string) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>