securemark 0.291.1 → 0.292.0

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

@@ -1,28 +1,27 @@
-import { Parser, Ctx, Node, Context, SubParsers, SubNode, eval, exec, check } from '../parser';
+import { Parser, CtxOptions, Node, Context, SubParsers, SubNode, eval, Ctx } from '../parser';
 import { push } from 'spica/array';
 
-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> {
+export function inits<P extends Parser<unknown, Ctx>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[]) => 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[]) => boolean): Parser<N, CtxOptions, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
-  return ({ source, context }) => {
-    let rest = source;
+  return input => {
+    const { context } = input;
+    const { source, position } = context;
     let nodes: N[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
-      if (rest === '') break;
-      if (context.delimiters?.match(rest, context)) break;
-      const result = parsers[i]({ source: rest, context });
-      assert(check(rest, result, false));
+      if (context.position === source.length) break;
+      if (context.delimiters?.match(context)) break;
+      const result = parsers[i](input);
       if (result === undefined) break;
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);
-      rest = exec(result);
-      if (resume?.(eval(result), exec(result)) === false) break;
+      if (resume?.(eval(result)) === false) break;
     }
-    assert(rest.length <= source.length);
-    return nodes && rest.length < source.length
-      ? [nodes, rest]
+    assert(context.position >= position);
+    return nodes && context.position > position
+      ? [nodes]
       : undefined;
   };
 }

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

@@ -1,31 +1,32 @@
-import { Parser } from '../parser';
+import { Parser, input } from '../parser';
 import { sequence } from './sequence';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/sequence', () => {
   describe('sequence', () => {
-    const a: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'a'
-        ? [['A'], source.slice(1)]
+    const a: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'a'
+        ? void ++context.position || [['A']]
         : undefined;
     };
-    const b: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'b'
-        ? [['B'], source.slice(1)]
+    const b: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'b'
+        ? void ++context.position || [['B']]
         : undefined;
     };
     const ab = sequence<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const { context: ctx } = input('', {});
 
     it('basic', () => {
       const parser = ab;
-      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'abb', context: {} })), [['A', 'B'], 'b']);
-      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('abb', ctx)), ctx), [['A', 'B'], 'b']);
+      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), undefined);
     });
 
   });

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

@@ -1,28 +1,27 @@
-import { Parser, Ctx, Node, Context, SubParsers, SubNode, eval, exec, check } from '../parser';
+import { Parser, CtxOptions, Node, Context, SubParsers, SubNode, eval } from '../parser';
 import { push } from 'spica/array';
 
-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> {
+export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[]) => 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[]) => boolean): Parser<N, CtxOptions, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
-  return ({ source, context }) => {
-    let rest = source;
+  return input => {
+    const { context } = input;
+    const { source, position } = context;
     let nodes: N[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
-      if (rest === '') return;
-      if (context.delimiters?.match(rest, context)) return;
-      const result = parsers[i]({ source: rest, context });
-      assert(check(rest, result, false));
+      if (context.position === source.length) return;
+      if (context.delimiters?.match(context)) return;
+      const result = parsers[i](input);
       if (result === undefined) return;
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);
-      rest = exec(result);
-      if (resume?.(eval(result), exec(result)) === false) return;
+      if (resume?.(eval(result)) === false) return;
     }
-    assert(rest.length <= source.length);
-    return nodes && rest.length < source.length
-      ? [nodes, rest]
+    assert(context.position >= position);
+    return nodes && context.position > position
+      ? [nodes]
       : undefined;
   };
 }

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

@@ -1,35 +1,36 @@
-import { Parser } from '../parser';
+import { Parser, input } from '../parser';
 import { union } from './union';
 import { some } from './some';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/some', () => {
   describe('some', () => {
-    const a: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'a'
-        ? [['A'], source.slice(1)]
+    const a: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'a'
+        ? void ++context.position || [['A']]
         : undefined;
     };
-    const b: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'b'
-        ? [['B'], source.slice(1)]
+    const b: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'b'
+        ? void ++context.position || [['B']]
         : undefined;
     };
     const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const { context: ctx } = input('', {});
 
     it('basic', () => {
       const parser = some(ab, /^aaa/);
-      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), [['B', 'A'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), [['A', 'A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), [['B', 'B', 'A'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'aaa', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'bbb', context: {} })), [['B', 'B', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'aaab', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'baaa', context: {} })), [['B'], 'aaa']);
+      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), [['B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), [['A', 'A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), [['B', 'B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser(input('aaa', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('bbb', ctx)), ctx), [['B', 'B', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('aaab', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('baaa', ctx)), ctx), [['B'], 'aaa']);
     });
 
   });

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

@@ -1,4 +1,4 @@
-import { Parser, eval, exec, check } from '../parser';
+import { Parser, eval } from '../parser';
 import { Delimiters } from './context/delimiter';
 import { unshift, push } from 'spica/array';
 
@@ -17,36 +17,34 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
     precedence,
     linebreakable,
   }));
-  return ({ source, context }) => {
-    if (source === '') return;
-    assert(context.backtracks ??= {});
-    let rest = source;
+  return input => {
+    const { context } = input;
+    const { source, position } = context;
+    //assert(context.backtracks ??= {});
     let nodes: N[] | undefined;
     if (delims.length > 0) {
       context.delimiters ??= new Delimiters();
       context.delimiters.push(delims);
     }
     while (true) {
-      if (rest === '') break;
-      if (match(rest)) break;
-      if (context.delimiters?.match(rest, context)) break;
-      const result = parser({ source: rest, context });
-      assert.doesNotThrow(() => limit === 0 && check(rest, result));
+      if (context.position === source.length) break;
+      if (match(context)) break;
+      if (context.delimiters?.match(context)) break;
+      const result = parser(input);
       if (result === undefined) break;
       nodes = nodes
         ? nodes.length < eval(result).length / 8
           ? unshift(nodes, eval(result))
           : push(nodes, eval(result))
         : eval(result);
-      rest = exec(result);
-      if (limit > 0 && source.length - rest.length > limit) break;
+      if (limit > 0 && context.position - position > limit) break;
     }
     if (delims.length > 0) {
       context.delimiters!.pop(delims.length);
     }
-    assert(rest.length <= source.length);
-    return nodes && rest.length < source.length
-      ? [nodes, rest]
+    assert(context.position >= position);
+    return nodes && context.position > position
+      ? [nodes]
       : undefined;
   };
 }

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

@@ -1,39 +1,40 @@
-import { Parser } from '../parser';
+import { Parser, input } from '../parser';
 import { subsequence } from './subsequence';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/subsequence', () => {
   describe('subsequence', () => {
-    const a: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'a'
-        ? [['A'], source.slice(1)]
+    const a: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'a'
+        ? void ++context.position || [['A']]
         : undefined;
     };
-    const b: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'b'
-        ? [['B'], source.slice(1)]
+    const b: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'b'
+        ? void ++context.position || [['B']]
         : undefined;
     };
-    const c: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'c'
-        ? [['C'], source.slice(1)]
+    const c: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'c'
+        ? void ++context.position || [['C']]
         : undefined;
     };
     const abc = subsequence<Parser<string, {}, [typeof a, typeof b, typeof c]>>([a, b, c]);
+    const { context: ctx } = input('', {});
 
     it('basic', () => {
       const parser = abc;
-      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'c', context: {} })), [['C'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), [['B'], 'a']);
-      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), [['A'], 'ab']);
-      assert.deepStrictEqual(inspect(parser({ source: 'abb', context: {} })), [['A', 'B'], 'b']);
-      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), [['B'], 'ba']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ac', context: {} })), [['A', 'C'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'bc', context: {} })), [['B', 'C'], '']);
+      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('c', ctx)), ctx), [['C'], '']);
+      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), [['B'], 'a']);
+      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), [['A'], 'ab']);
+      assert.deepStrictEqual(inspect(parser(input('abb', ctx)), ctx), [['A', 'B'], 'b']);
+      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), [['B'], 'ba']);
+      assert.deepStrictEqual(inspect(parser(input('ac', ctx)), ctx), [['A', 'C'], '']);
+      assert.deepStrictEqual(inspect(parser(input('bc', ctx)), ctx), [['B', 'C'], '']);
     });
 
   });

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

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

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

@@ -1,31 +1,32 @@
-import { Parser } from '../parser';
+import { Parser, input } from '../parser';
 import { union } from './union';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/union', () => {
   describe('union', () => {
-    const a: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'a'
-        ? [['A'], source.slice(1)]
+    const a: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'a'
+        ? void ++context.position || [['A']]
         : undefined;
     };
-    const b: Parser<string, never> = ({ source }) => {
-      return source && source[0] === 'b'
-        ? [['B'], source.slice(1)]
+    const b: Parser<string> = ({ context }) => {
+      return context.source[context.position] === 'b'
+        ? void ++context.position || [['B']]
         : undefined;
     };
     const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const { context: ctx } = input('', {});
 
     it('basic', () => {
       const parser = ab;
-      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A'], 'b']);
-      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), [['B'], 'a']);
-      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), [['A'], 'ab']);
-      assert.deepStrictEqual(inspect(parser({ source: 'abb', context: {} })), [['A'], 'bb']);
-      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), [['B'], 'ba']);
+      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A'], 'b']);
+      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), [['B'], 'a']);
+      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), [['A'], 'ab']);
+      assert.deepStrictEqual(inspect(parser(input('abb', ctx)), ctx), [['A'], 'bb']);
+      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), [['B'], 'ba']);
     });
 
   });

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

@@ -1,7 +1,7 @@
-import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
 
 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> {
+export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, CtxOptions, D> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0:

package/src/combinator/data/parser.ts

@@ -1,16 +1,20 @@
 import { Delimiters } from './parser/context/delimiter';
+import { MarkdownParser } from '../../../markdown';
 
-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<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
-  = readonly [N[], string, C, D]
-  | readonly [N[], string]
+export type Parser<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
+  = (input: Input<C & Ctx>) => Result<N, C, D>;
+export interface Input<C extends CtxOptions = CtxOptions> {
+  readonly context: C & Ctx;
+}
+export type Result<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
+  = readonly [N[], C, D]
+  | readonly [N[]]
   | undefined;
-export interface Ctx {
+export interface Ctx extends CtxOptions {
+  source: string;
+  position: number;
+}
+export interface CtxOptions {
   readonly resources?: {
     clock: number;
     recursions: number[];
@@ -24,16 +28,52 @@ export interface Ctx {
   // AVL木が適当と思われる。
   backtracks?: Record<number, number>;
   linebreak?: number;
-  recent?: string[];
+  range?: number;
 }
 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 SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, CtxOptions, infer D> ? D : never;
+export type Context<P extends Parser<unknown>> = P extends Parser<unknown, infer C> ? C & Ctx : 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 function input(source: string, context: CtxOptions): Input<Ctx>;
+export function input(source: string, context: MarkdownParser.Options): Input<MarkdownParser.Context>;
+export function input(source: string, context: CtxOptions): Input<Ctx> {
+  // @ts-expect-error
+  context.source = source;
+  // @ts-expect-error
+  context.position = 0;
+  return {
+    source,
+    // @ts-expect-error
+    context,
+  };
+}
+
+export function subinput<C extends Ctx>(source: string, context: C): Input<C> {
+  return {
+    context: {
+      ...context,
+      source,
+      position: 0,
+      offset: undefined,
+      backtracks: {},
+    }
+  };
+}
+
+export function clean<C extends Ctx>(context: C): C {
+  const { source, position } = context;
+  for (const p of Object.keys(context)) {
+    context[p] = undefined;
+  }
+  context.source = source;
+  context.position = position;
+  return context;
+}
+
 export { eval_ as eval };
 function eval_<N>(result: NonNullable<Result<N>>, default_?: N[]): N[];
 function eval_<N>(result: Result<N>, default_: N[]): N[];
@@ -44,19 +84,17 @@ function eval_<N>(result: Result<N>, default_?: N[]): N[] | undefined {
     : default_;
 }
 
-export function exec(result: NonNullable<Result<unknown>>, default_?: ''): string;
-export function exec(result: Result<unknown>, default_: ''): string
-export function exec(result: Result<unknown>, default_?: undefined): string | undefined;
-export function exec(result: Result<unknown>, default_?: string): string | undefined {
-  return result
-    ? result[1]
-    : default_;
-}
-
-export function check(source: string, result: Result<unknown>, mustConsume = true): true {
-  assert.doesNotThrow(() => {
-    if (source.length > 1000) return;
-    if (source.slice(+mustConsume).slice(-exec(result, '').length || source.length) !== exec(result, '')) throw new Error();
-  });
-  return true;
+export function failsafe<P extends Parser<unknown>>(parser: P): P;
+export function failsafe<N>(parser: Parser<N>): Parser<N> {
+  assert(parser);
+  return input => {
+    const { context } = input;
+    const { source, position } = context;
+    const result = parser(input);
+    if (result === undefined) {
+      context.source = source;
+      context.position = position;
+    }
+    return result;
+  };
 }

package/src/debug.test.ts

@@ -1,8 +1,8 @@
-import { Result, eval, exec } from './combinator/data/parser';
+import { Result, Ctx, eval } from './combinator/data/parser';
 import { html, define } from 'typed-dom/dom';
 import { querySelectorWith, querySelectorAllWith } from 'typed-dom/query';
 
-export function inspect(result: Result<HTMLElement | string>, until: number | string = Infinity): Result<string> {
+export function inspect(result: Result<HTMLElement | string>, ctx: Ctx, until: number | string = Infinity): [string[], string] | undefined {
   return result && [
     eval(result).map(node => {
       assert(node);
@@ -33,7 +33,7 @@ export function inspect(result: Result<HTMLElement | string>, until: number | st
       }
       return normalize(node.outerHTML.slice(0, until));
     }),
-    exec(result)
+    ctx.source.slice(ctx.position),
   ];
 }
 

package/src/parser/api/bind.ts

@@ -1,6 +1,6 @@
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
-import { eval } from '../../combinator/data/parser';
+import { input, eval } from '../../combinator/data/parser';
 import { segment, validate, MAX_INPUT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
@@ -19,7 +19,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   nearest: (position: number) => HTMLElement | undefined;
   index: (block: HTMLElement) => number;
 } {
-  let context: MarkdownParser.Context = {
+  let context: MarkdownParser.Options = {
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
   };
@@ -78,7 +78,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = eval(header({ source: seg, context: { header: index === 0 } }) || block({ source: seg, context }), []);
+      const es = eval(header(input(seg, { header: index === 0 })) || block(input(seg, context)), []);
       blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.

package/src/parser/api/header.ts

@@ -1,9 +1,9 @@
-import { eval, exec } from '../../combinator/data/parser';
+import { input, eval } from '../../combinator/data/parser';
 import { header as h } from '../header';
 
 export function header(source: string): string {
-  const [, rest = source] = parse(source);
-  return source.slice(0, source.length - rest.length);
+  const [, pos = 0] = parse(source);
+  return source.slice(0, pos);
 }
 
 export function headers(source: string): string[] {
@@ -11,10 +11,11 @@ export function headers(source: string): string[] {
   return el?.textContent!.trimEnd().slice(el.firstChild!.firstChild!.textContent!.length).split('\n') ?? [];
 }
 
-function parse(source: string): [HTMLElement, string] | [] {
-  const result = h({ source, context: {} });
+function parse(source: string): [HTMLElement, number] | [] {
+  const i = input(source, {});
+  const result = h(i);
   const [el] = eval(result, []);
   return el?.tagName === 'ASIDE'
-    ? [el, exec(result!)]
+    ? [el, i.context.position]
     : [];
 }

package/src/parser/api/normalize.ts

@@ -1,4 +1,4 @@
-import { eval } from '../../combinator/data/parser';
+import { input, eval } from '../../combinator/data/parser';
 import { unsafehtmlentity } from '../inline/htmlentity';
 
 const UNICODE_REPLACEMENT_CHARACTER = '\uFFFD';
@@ -60,7 +60,7 @@ export const invisibleHTMLEntityNames = [
 ] as const;
 const unreadableHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames.slice(2);
 const unreadableEscapableCharacters = unreadableHTMLEntityNames
-  .map(name => eval(unsafehtmlentity({ source: `&${name};`, context: {} }))![0]);
+  .map(name => eval(unsafehtmlentity(input(`&${name};`, {})))![0]);
 assert(unreadableEscapableCharacters.length === unreadableHTMLEntityNames.length);
 assert(unreadableEscapableCharacters.every(c => c.length === 1));
 const unreadableEscapableCharacter = new RegExp(`[${