securemark 0.289.2 → 0.289.3

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

@@ -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) =>

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

@@ -1,8 +1,8 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
-export function tails<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 tails<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function tails<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 tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

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

@@ -1,7 +1,7 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 
-export function union<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function union<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function union<P extends Parser<unknown>>(parsers: SubParsers<P>): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0:

package/src/combinator/data/parser.ts

@@ -1,14 +1,14 @@
 import { Delimiters } from './parser/context/delimiter';
 
-export type Parser<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
-  = (input: Input<C>) => Result<T, C, D>;
+export type Parser<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
+  = (input: Input<C>) => Result<N, C, D>;
 export interface Input<C extends Ctx = Ctx> {
   readonly source: string;
   readonly context: C;
 }
-export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
-  = readonly [T[], string, C, D]
-  | readonly [T[], string]
+export type Result<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
+  = readonly [N[], string, C, D]
+  | readonly [N[], string]
   | undefined;
 export interface Ctx {
   readonly resources?: {
@@ -24,19 +24,19 @@ export interface Ctx {
   linebreak?: number;
   recent?: string[];
 }
-export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;
+export type Node<P extends Parser<unknown>> = P extends Parser<infer N> ? N : never;
 export type SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, Ctx, infer D> ? D : never;
 export type Context<P extends Parser<unknown>> = P extends Parser<unknown, infer C> ? C : never;
-export type SubTree<P extends Parser<unknown>> = ExtractSubTree<SubParsers<P>>;
-export type IntermediateParser<P extends Parser<unknown>> = Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-type ExtractSubTree<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer T ? T extends Parser<infer U> ? U : never : never;
+export type SubNode<P extends Parser<unknown>> = ExtractSubNode<SubParsers<P>>;
+export type IntermediateParser<P extends Parser<unknown>> = Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+type ExtractSubNode<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer N ? N extends Parser<infer U> ? U : never : never;
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
 export { eval_ as eval };
-function eval_<T>(result: NonNullable<Result<T>>, default_?: T[]): T[];
-function eval_<T>(result: Result<T>, default_: T[]): T[];
-function eval_<T>(result: Result<T>, default_?: undefined): T[] | undefined;
-function eval_<T>(result: Result<T>, default_?: T[]): T[] | undefined {
+function eval_<N>(result: NonNullable<Result<N>>, default_?: N[]): N[];
+function eval_<N>(result: Result<N>, default_: N[]): N[];
+function eval_<N>(result: Result<N>, default_?: undefined): N[] | undefined;
+function eval_<N>(result: Result<N>, default_?: N[]): N[] | undefined {
   return result
     ? result[0]
     : default_;

package/src/combinator.ts

@@ -11,6 +11,7 @@ export * from './combinator/control/constraint/contract';
 export * from './combinator/control/manipulation/fence';
 export * from './combinator/control/manipulation/indent';
 export * from './combinator/control/manipulation/scope';
+export * from './combinator/control/manipulation/clear';
 export * from './combinator/control/manipulation/surround';
 export * from './combinator/control/manipulation/match';
 export * from './combinator/control/manipulation/convert';

package/src/parser/block/extension/figure.ts

@@ -43,7 +43,7 @@ export const segment: FigureParser.SegmentParser = block(match(
       ]),
     ]),
     closer),
-  ([, fence]) => fence.length, {}), false));
+  ([, fence]) => fence.length, {})));
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),

package/src/parser/block/extension/table.ts

@@ -1,7 +1,7 @@
 import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
-import { Tree, eval } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, block, line, validate, fence, rewrite, surround, open, clear, convert, dup, lazy, fmap } from '../../../combinator';
+import { Node, eval } from '../../../combinator/data/parser';
+import { union, subsequence, inits, some, block, line, validate, fence, rewrite, clear, surround, open, convert, dup, lazy, fmap } from '../../../combinator';
 import { inline, medialink, media, shortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { lineable, invalid } from '../../util';
@@ -147,7 +147,7 @@ function attributes(source: string): Record<string, string | undefined> {
   };
 }
 
-function format(rows: Tree<RowParser>[]): HTMLTableSectionElement[] {
+function format(rows: Node<RowParser>[]): HTMLTableSectionElement[] {
   const thead = html('thead');
   const tbody = html('tbody');
   const tfoot = html('tfoot');