securemark 0.289.2 → 0.289.4

package/src/combinator/control/constraint/contract.ts

@@ -1,16 +1,16 @@
 import { isArray } from 'spica/alias';
-import { Parser, Input, Ctx, Tree, Context, eval, exec, check } from '../../data/parser';
+import { Parser, Input, Ctx, Node, Context, eval, exec, check } from '../../data/parser';
 
 //export function contract<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
-//export function contract<T>(patterns: string | RegExp | (string | RegExp)[], parser: Parser<T>, cond: (nodes: readonly T[], rest: string) => boolean): Parser<T> {
+//export function contract<N>(patterns: string | RegExp | (string | RegExp)[], parser: Parser<N>, cond: (nodes: readonly N[], rest: string) => boolean): Parser<N> {
 //  return verify(validate(patterns, parser), cond);
 //}
 
 export function validate<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P): P;
 export function validate<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], has: string, parser: P): P;
 export function validate<P extends Parser<unknown>>(cond: ((input: Input<Context<P>>) => boolean), parser: P): P;
-export function validate<T>(patterns: string | RegExp | (string | RegExp)[] | ((input: Input<Ctx>) => boolean), has: string | Parser<T>, parser?: Parser<T>): Parser<T> {
-  if (typeof patterns === 'function') return guard(patterns, has as Parser<T>);
+export function validate<N>(patterns: string | RegExp | (string | RegExp)[] | ((input: Input<Ctx>) => boolean), has: string | Parser<N>, parser?: Parser<N>): Parser<N> {
+  if (typeof patterns === 'function') return guard(patterns, has as Parser<N>);
   if (typeof has === 'function') return validate(patterns, '', has);
   if (!isArray(patterns)) return validate([patterns], has, parser!);
   assert(patterns.length > 0);
@@ -38,15 +38,15 @@ export function validate<T>(patterns: string | RegExp | (string | RegExp)[] | ((
 }
 
 function guard<P extends Parser<unknown>>(f: (input: Input<Context<P>>) => boolean, parser: P): P;
-function guard<T>(f: (input: Input<Ctx>) => boolean, parser: Parser<T>): Parser<T> {
+function guard<N>(f: (input: Input<Ctx>) => boolean, parser: Parser<N>): Parser<N> {
   return input =>
     f(input)
       ? parser(input)
       : undefined;
 }
 
-export function verify<P extends Parser<unknown>>(parser: P, cond: (nodes: readonly Tree<P>[], rest: string, context: Context<P>) => boolean): P;
-export function verify<T>(parser: Parser<T>, cond: (nodes: readonly T[], rest: string, context: Ctx) => boolean): Parser<T> {
+export function verify<P extends Parser<unknown>>(parser: P, cond: (nodes: readonly Node<P>[], rest: string, context: Context<P>) => boolean): P;
+export function verify<N>(parser: Parser<N>, cond: (nodes: readonly N[], rest: string, context: Ctx) => boolean): Parser<N> {
   assert(parser);
   return input => {
     const { source, context } = input;

package/src/combinator/control/constraint/line.ts

@@ -1,7 +1,7 @@
 import { Parser, eval, exec, check } from '../../data/parser';
 
 export function line<P extends Parser<unknown>>(parser: P): P;
-export function line<T>(parser: Parser<T>): Parser<T> {
+export function line<N>(parser: Parser<N>): Parser<N> {
   assert(parser);
   return ({ source, context }) => {
     if (source === '') return;

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

@@ -0,0 +1,7 @@
+import { Parser, Ctx } from '../../data/parser';
+import { fmap } from '../monad/fmap';
+
+
+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, () => []);
+}

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

@@ -1,7 +1,7 @@
 import { Parser, Ctx, Context, check } from '../../data/parser';
 
 export function convert<P extends Parser<unknown>>(conv: (source: string, context: Context<P>) => string, parser: P, continuous: boolean, empty?: boolean): P;
-export function convert<T>(conv: (source: string, context: Ctx) => string, parser: Parser<T>, continuous: boolean, empty = false): Parser<T> {
+export function convert<N>(conv: (source: string, context: Ctx) => string, parser: Parser<N>, continuous: boolean, empty = false): Parser<N> {
   assert(parser);
   return ({ source, context }) => {
     if (source === '') return;

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

@@ -1,8 +1,8 @@
-import { Parser, Ctx, Tree, Context, SubParsers } from '../../data/parser';
+import { Parser, Ctx, Node, Context, SubParsers } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 
-export function dup<P extends Parser<unknown[]>>(parser: Parser<Tree<P>[number], Context<P>, SubParsers<P>>): P;
-export function dup<T, C extends Ctx, D extends Parser<unknown, C>[]>(parser: Parser<T, C, D>): Parser<T[], C, D>;
-export function dup<T>(parser: Parser<T>): Parser<T[]> {
+export function dup<P extends Parser<unknown[]>>(parser: Parser<Node<P>[number], Context<P>, SubParsers<P>>): P;
+export function dup<N, C extends Ctx, D extends Parser<unknown, C>[]>(parser: Parser<N, C, D>): Parser<N[], C, D>;
+export function dup<N>(parser: Parser<N>): Parser<N[]> {
   return fmap(parser, nodes => [nodes]);
 }

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[],
   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[],
   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[],
   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[],
   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[] = [],
   backtrackstate: number = 0,
-): Parser<T> {
+): Parser<N> {
   switch (typeof opener) {
     case 'string':
     case 'object':
@@ -54,21 +53,22 @@ export function surround<T>(
   }
   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;
           const shift = backtrack >>> statesize & state >>> statesize ? state & (1 << statesize) - 1 : 0;
           if (backtracks[pos] & 1 << size(backtrack >>> statesize) + shift) return void revert(context, linebreak);
@@ -77,35 +77,37 @@ export function surround<T>(
     }
     const { backtrack = 0 } = context;
     context.backtrack = backtrack | backtrackstate;
-    const res2 = mr_ !== '' ? parser({ source: mr_, context }) : undefined;
-    assert(check(mr_, res2));
+    const resultM = me_ !== '' ? parser({ source: me_, context }) : undefined;
+    assert(check(me_, resultM));
     context.backtrack = backtrack;
-    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 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;
+        const pos = source.length + offset - 1;
+        assert(pos >= 0);
         const shift = backtrack >>> statesize & state >>> statesize ? state & (1 << statesize) - 1 : 0;
-        backtracks[source.length + offset - 1] |= 1 << size(backtrack >>> statesize) + shift;
+        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;
@@ -116,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) {
@@ -130,12 +140,16 @@ function match(pattern: string | RegExp): (input: Input) => [never[], string] |
       };
   }
 }
+function revert(context: Ctx, linebreak: number | undefined): void {
+  context.linebreak = linebreak;
+}
 function size(bits: number): number {
   if (bits === 0) return 0;
   let p = 0;
   for (let s = 32 / 2; s > 0; s >>>= 1) {
-    if (bits >>> p + s === 0) continue;
-    p += s;
+    const q = p + s;
+    if (bits >>> q === 0) continue;
+    p = q;
   }
   return p + 1;
 }
@@ -144,19 +158,3 @@ assert(size(1 << 0) === 1);
 assert(size(1 << 1) === 2);
 assert(size(1 << 30) === 31);
 assert(size(1 << 31) === 32);
-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, () => []);
-}

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

@@ -1,9 +1,9 @@
 import { Ctx } from '../../parser';
-import { memoize } from 'spica/memoize';
 
 interface Delimiter {
+  readonly memory: Delimiter[];
   readonly index: number;
-  readonly signature: string;
+  readonly signature: number | string;
   readonly matcher: (source: string) => boolean | undefined;
   readonly precedence: number;
   readonly linebreakable: boolean;
@@ -11,54 +11,74 @@ interface Delimiter {
 }
 
 export class Delimiters {
-  public static signature(pattern: string | RegExp | undefined): string {
+  // 手間を惜しまなければ規定のパターンはすべて配列のインデクスに変換可能。
+  public static signature(pattern: string | RegExp | undefined, linebreakable: boolean): number | string {
     switch (typeof pattern) {
       case 'undefined':
-        return `undefined`;
+        return +linebreakable;
       case 'string':
-        return `s:${pattern}`;
+        assert(pattern !== '\x00');
+        if (pattern.length === 1) {
+          const code = pattern.charCodeAt(0);
+          // 使用中のパターンの8ビット目が空いてるのでひとまずこうしとく
+          if ((code & 1 << 7) === 0) return code | +linebreakable << 7;
+        }
+        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;
+    }
+  }
+  private readonly heap: Record<number, Delimiter[]> = {};
+  private readonly map: Map<string, Delimiter[]> = new Map();
+  private registry(signature: number | string): Delimiter[] {
+    if (typeof signature === 'number') {
+      return this.heap[signature] ??= [];
+    }
+    else {
+      const ds = this.map.get(signature);
+      if (ds) return ds;
+      const blank: Delimiter[] = [];
+      this.map.set(signature, blank);
+      return blank;
     }
   }
-  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[] = [];
   private readonly states: (readonly number[])[] = [];
   public push(
     delims: readonly {
-      readonly signature: string;
+      readonly signature: number | string;
       readonly matcher: (source: string) => boolean | undefined;
       readonly precedence: number;
       readonly linebreakable: boolean;
     }[]
   ): void {
-    const { registry, delimiters, stack } = this;
+    const { delimiters, stack } = this;
     // シグネチャ数以下
     assert(delimiters.length < 100);
     for (let i = 0; i < delims.length; ++i) {
       const { signature, matcher, precedence, linebreakable } = delims[i];
-      const memory = registry(signature);
+      const memory = this.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 +94,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 +108,7 @@ export class Delimiters {
         delimiters.pop();
       }
       else {
+        assert(false);
         memory.pop();
         delimiters[index] = memory.at(-1)!;
       }