securemark 0.291.0 → 0.292.0

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

@@ -1,32 +1,32 @@
-import { Parser, Context, eval, exec, check } from '../../data/parser';
+import { Parser, Context, input, eval, failsafe } 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<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'
-    ? source => source.slice(0, scope.length) === scope ? scope : ''
-    : source => source.match(scope)?.[0] ?? '';
-  return ({ source, context }) => {
-    if (source === '') return;
-    const src = match(source);
-    assert(source.startsWith(src));
+  const match: (source: string, position: number) => string = typeof scope === 'string'
+    ? (source, position) => source.startsWith(scope, position) ? scope : ''
+    : (source, position) => source.slice(position).match(scope)?.[0] ?? '';
+  return failsafe(({ context }) => {
+    const { source, position } = context;
+    if (position === source.length) return;
+    const src = match(source, position);
+    assert(source.startsWith(src, position));
     if (src === '') return;
     cost && consume(src.length, context);
-    const offset = source.length - src.length;
-    assert(offset >= 0);
+    context.range = src.length;
     context.offset ??= 0;
-    context.offset += offset;
-    const result = parser({ source: src, context });
-    assert(check(src, result));
-    context.offset -= offset;
+    context.offset += position;
+    const result = parser(input(src, context));
+    context.position += position;
+    context.position += result && context.position === position ? src.length : 0;
+    assert(context.position > position || !result);
+    context.source = source;
+    context.offset -= position;
     if (result === undefined) return;
-    assert(exec(result).length < src.length);
-    return exec(result).length < src.length
-      ? [eval(result), exec(result) + source.slice(src.length)]
-      : undefined;
-  };
+    return [eval(result)];
+  });
 }
 
 //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>;
@@ -34,30 +34,29 @@ export function rewrite<P extends Parser<unknown>>(scope: Parser<unknown, Contex
 export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>): Parser<N> {
   assert(scope);
   assert(parser);
-  return input => {
-    const { source, context } = input;
-    if (source === '') return;
+  return failsafe(({ context }) => {
+    const { source, position } = context;
+    if (position === source.length) return;
     // 影響する使用はないはず
     //const { backtracks } = context;
     //context.backtracks = {};
-    const res1 = scope(input);
-    assert(check(source, res1));
+    const res1 = scope({ context });
+    assert(context.position > position || !res1);
     //context.backtracks = backtracks;
-    if (res1 === undefined || exec(res1).length >= source.length) return;
-    const src = source.slice(0, source.length - exec(res1).length);
+    if (res1 === undefined || context.position < position) return;
+    const src = source.slice(position, context.position);
     assert(src !== '');
-    assert(source.startsWith(src));
-    const offset = source.length - src.length;
-    assert(offset >= 0);
+    assert(source.startsWith(src, position));
     context.offset ??= 0;
-    context.offset += offset;
-    const res2 = parser({ source: src, context });
-    assert(check(src, res2));
-    context.offset -= offset;
+    context.offset += position;
+    const res2 = parser(input(src, context));
+    context.position += position;
+    context.position += res2 && context.position === position ? src.length : 0;
+    assert(context.position > position || !res2);
+    context.source = source;
+    context.offset -= position;
     if (res2 === undefined) return;
-    assert(exec(res2) === '');
-    return exec(res2).length < src.length
-      ? [eval(res2), exec(res2) + exec(res1)]
-      : undefined;
-  };
+    assert(context.position === position + src.length);
+    return [eval(res2)];
+  });
 }

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

@@ -1,40 +1,40 @@
-import { Parser, Input, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, exec, check } from '../../data/parser';
+import { Parser, Input, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
 import { consume } from '../../../combinator';
 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[], 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>>,
+  f?: (rss: [S[], SubNode<P>[], S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], SubNode<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly 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[], 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>>,
+  f?: (rss: [S[], SubNode<P>[] | undefined, S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], SubNode<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly 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[], 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>>,
+  f?: (rss: [S[], Node<P>[], S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], Node<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly 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[], 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>>,
+  f?: (rss: [S[], Node<P>[] | undefined, S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], Node<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
 ): P;
 export function surround<N>(
   opener: string | RegExp | Parser<N>, parser: Parser<N>, closer: string | RegExp | Parser<N>,
   optional: boolean = false,
-  f?: (rss: [N[], N[], N[]], rest: string, context: Ctx) => Result<N>,
-  g?: (rss: [N[], N[], string], rest: string, context: Ctx) => Result<N>,
+  f?: (rss: [N[], N[], N[]], context: Ctx) => Result<N>,
+  g?: (rss: [N[], N[] | undefined], context: Ctx) => Result<N>,
   backtracks: readonly number[] = [],
 ): Parser<N> {
   switch (typeof opener) {
@@ -47,40 +47,48 @@ export function surround<N>(
     case 'object':
       closer = match(closer);
   }
-  return ({ source, context }) => {
-    const sme_ = source;
-    if (sme_ === '') return;
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
     const { linebreak } = context;
     context.linebreak = 0;
-    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);
-    if (isBacktrack(context, backtracks, sme_, sme_.length - me_.length)) return void revert(context, linebreak);
-    const resultM = me_ !== '' ? parser({ source: me_, context }) : undefined;
-    assert(check(me_, resultM));
+    const resultO = opener(input);
+    assert(context.position >= position);
+    const nodesO = eval(resultO);
+    if (!nodesO) {
+      return void revert(context, linebreak);
+    }
+    if (isBacktrack(context, backtracks, position, context.position - position || 1)) {
+      return void revert(context, linebreak);
+    }
+    const resultM = context.position < source.length ? parser(input) : undefined;
+    assert(context.position >= position);
+    context.range = context.position - position;
     const nodesM = eval(resultM);
-    const e_ = exec(resultM) ?? me_;
-    const resultE = nodesM || optional ? closer({ source: e_, context }) : undefined;
-    assert(check(e_, resultE, false));
-    const nodesE = eval(resultE);
-    const rest = exec(resultE) ?? e_;
-    nodesE || setBacktrack(context, backtracks, sme_.length);
-    if (!nodesM && !optional) return void revert(context, linebreak);
-    if (rest.length === sme_.length) return void revert(context, linebreak);
-    context.recent = [
-      sme_.slice(0, sme_.length - me_.length),
-      me_.slice(0, me_.length - e_.length),
-      e_.slice(0, e_.length - rest.length),
-    ];
-    const result = nodesE
-      ? f
-        ? f([nodesS, nodesM!, nodesE], rest, context)
-        : [push(unshift(nodesS, nodesM ?? []), nodesE), rest] satisfies [N[], string]
-      : g
-        ? g([nodesS, nodesM!, me_], rest, context)
-        : undefined;
+    if (!resultM && !optional) {
+      setBacktrack(context, backtracks, position);
+      const result = g?.([nodesO, nodesM], context);
+      revert(context, linebreak);
+      return result;
+    }
+    const resultC = resultM || optional ? closer(input) : undefined;
+    assert(context.position >= position);
+    context.range = context.position - position;
+    const nodesC = eval(resultC);
+    if (!nodesC) {
+      setBacktrack(context, backtracks, position);
+      const result = g?.([nodesO, nodesM], context);
+      revert(context, linebreak);
+      return result;
+    }
+    if (context.position === position) {
+      return void revert(context, linebreak);
+    }
+    context.range = context.position - position;
+    const result = f
+      ? f([nodesO, nodesM!, nodesC], context)
+      : [push(nodesM ? unshift(nodesO, nodesM) : nodesO, nodesC)] satisfies [N[]];
     if (result) {
       context.linebreak ||= linebreak;
     }
@@ -88,7 +96,7 @@ export function surround<N>(
       revert(context, linebreak);
     }
     return result;
-  };
+  });
 }
 export function open<P extends Parser<unknown>>(
   opener: string | RegExp | Parser<Node<P>, Context<P>>,
@@ -97,7 +105,7 @@ export function open<P extends Parser<unknown>>(
   backtracks?: readonly number[],
 ): P;
 export function open<N>(
-  opener: string | RegExp | Parser<N>,
+  opener: string | RegExp | Parser<N, Ctx>,
   parser: Parser<N>,
   optional?: boolean,
   backtracks?: readonly number[],
@@ -112,7 +120,7 @@ export function close<P extends Parser<unknown>>(
 ): P;
 export function close<N>(
   parser: Parser<N>,
-  closer: string | RegExp | Parser<N>,
+  closer: string | RegExp | Parser<N, Ctx>,
   optional?: boolean,
   backtracks?: readonly number[],
 ): Parser<N> {
@@ -123,18 +131,19 @@ const statesize = 2;
 export function isBacktrack(
   context: Ctx,
   backtracks: readonly number[],
-  source: string,
+  position: number = context.position,
   length: number = 1,
 ): boolean {
-  if (length === 0 || source.length === 0) return false;
+  const { source } = context;
+  if (position === source.length) return false;
+  if (length === 0) return false;
   for (const backtrack of backtracks) {
     if (backtrack & 1) {
       const { backtracks = {}, offset = 0 } = context;
       for (let i = 0; i < length; ++i) {
-        assert(i < source.length);
-        if (source[i] !== source[0]) break;
-        const pos = source.length - i + offset - 1;
-        assert(pos >= 0);
+        if (position + i === source.length) break;
+        if (source[position + i] !== source[position + 0]) break;
+        const pos = position + i + offset;
         if (!(pos in backtracks)) continue;
         if (backtracks[pos] & 1 << size(backtrack >>> statesize)) return true;
       }
@@ -148,29 +157,38 @@ export function setBacktrack(
   position: number,
   length: number = 1,
 ): void {
-  if (length === 0 || position === 0) return;
+  const { source } = context;
+  if (position === source.length) return;
+  if (length === 0) return;
   for (const backtrack of backtracks) {
-    if (backtrack & 2 && position !== 0) {
+    if (backtrack & 2) {
       const { backtracks = {}, offset = 0 } = context;
       for (let i = 0; i < length; ++i) {
-        const pos = position - i + offset - 1;
-        assert(pos >= 0);
+        if (position + i === source.length) break;
+        const pos = position + i + offset;
         backtracks[pos] |= 1 << size(backtrack >>> statesize);
       }
     }
   }
 }
 
-function match(pattern: string | RegExp): (input: Input) => [never[], string] | undefined {
+function match(pattern: string | RegExp): (input: Input) => Result<never> {
   switch (typeof pattern) {
     case 'string':
-      return ({ source }) => source.slice(0, pattern.length) === pattern ? [[], source.slice(pattern.length)] : undefined;
+      return ({ context }) => {
+        const { source, position } = context;
+        if (!source.startsWith(pattern, position)) return;
+        context.position += pattern.length;
+        return [[]];
+      };
     case 'object':
-      return ({ source, context }) => {
-        const m = source.match(pattern);
+      return ({ context }) => {
+        const { source, position } = context;
+        const m = source.slice(position).match(pattern);
         if (m === null) return;
         consume(m[0].length, context);
-        return [[], source.slice(m[0].length)];
+        context.position += m[0].length;
+        return [[]];
       };
   }
 }

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

@@ -1,18 +1,21 @@
 import { trim } from './trim';
+import { input } from '../../data/parser';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/trim', () => {
   describe('trim', () => {
+    const { context: ctx } = input('', {});
+
     it('', () => {
-      const parser = trim(({ source }) => [[source], '']);
-      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'a\n', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'a ', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: 'a \n', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: ' a', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: ' a ', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: ' a \n b \n', context: {} })), [['a \n b'], '']);
+      const parser = trim(({ context }) => { context.position = context.source.length; return [[context.source]]; });
+      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('a\n', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('a ', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('a \n', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a ', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a \n b \n', ctx)), ctx), [['a \n b'], '']);
     });
 
   });

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

@@ -1,24 +1,24 @@
-import { Parser, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, exec, check } from '../../data/parser';
+import { Parser, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
 
-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> {
+export function bind<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubNode<P>[], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
+export function bind<P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], 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[], 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>[], 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[], context: Ctx) => Result<U>): Parser<U> {
   assert(parser);
-  return input => {
-    const { source, context } = input;
-    if (source === '') return;
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
     const res1 = parser(input);
-    assert(check(source, res1));
+    assert(context.position > position || !res1);
     if (res1 === undefined) return;
-    context.recent = [source.slice(0, source.length - exec(res1).length)];
-    const res2 = f(eval(res1), exec(res1), context);
-    assert(check(source, res2));
-    assert(check(exec(res1), res2, false));
+    context.range = context.position - position;
+    const res2 = f(eval(res1), context);
+    assert(context.position > position || !res2);
     if (res2 === undefined) return;
-    return exec(res2).length <= exec(res1).length
+    return context.position > position
       ? res2
       : undefined;
-  };
+  });
 }

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

@@ -1,10 +1,10 @@
 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: 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]);
+export function fmap<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubNode<P>[], context: Context<P>) => Node<P>[]): P;
+export function fmap<P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], context: Context<P>) => Node<P>[]): P;
+export function fmap<N, P extends Parser<unknown>>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: N[], context: Context<P>) => Node<P>[]): P;
+export function fmap<U, P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], context: Context<P>) => U[]): Parser<U, Context<P>, SubParsers<P>>;
+export function fmap<N, U>(parser: Parser<N>, f: (nodes: N[], context: Ctx) => U[]): Parser<U> {
+  return bind(parser, (nodes, context) => [f(nodes, context)]);
 }

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

@@ -4,7 +4,7 @@ interface Delimiter {
   readonly memory: Delimiter[];
   readonly index: number;
   readonly signature: number | string;
-  readonly matcher: (source: string) => boolean | undefined;
+  readonly matcher: (context: Ctx) => boolean | undefined;
   readonly precedence: number;
   readonly linebreakable: boolean;
   state: boolean;
@@ -28,14 +28,14 @@ export class Delimiters {
         return `r/${pattern.source}/${+linebreakable}`;
     }
   }
-  public static matcher(pattern: string | RegExp | undefined): (source: string) => true | undefined {
+  public static matcher(pattern: string | RegExp | undefined): (context: Ctx) => true | undefined {
     switch (typeof pattern) {
       case 'undefined':
         return () => undefined;
       case 'string':
-        return source => source.slice(0, pattern.length) === pattern || undefined;
+        return ({ source, position }) => source.startsWith(pattern, position) || undefined;
       case 'object':
-        return source => pattern.test(source) || undefined;
+        return ({ source, position }) => pattern.test(source.slice(position)) || undefined;
     }
   }
   private readonly tree: Record<number, Delimiter[]> = {};
@@ -58,7 +58,7 @@ export class Delimiters {
   public push(
     delims: readonly {
       readonly signature: number | string;
-      readonly matcher: (source: string) => boolean | undefined;
+      readonly matcher: (context: Ctx) => boolean | undefined;
       readonly precedence: number;
       readonly linebreakable: boolean;
     }[]
@@ -132,12 +132,13 @@ export class Delimiters {
       delimiters[indexes[i]].state = true;
     }
   }
-  public match(source: string, { precedence = 0, linebreak = 0 }: Ctx): boolean {
+  public match(context: Ctx): boolean {
+    const { precedence = 0, linebreak = 0 } = context;
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];
       if (delimiter.precedence <= precedence || !delimiter.state) continue;
-      switch (delimiter.matcher(source)) {
+      switch (delimiter.matcher(context)) {
         case true:
           if (!delimiter.linebreakable && linebreak > 0) return false;
           return true;

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

@@ -1,53 +1,58 @@
-import { Parser, Ctx } from '../parser';
+import { Parser, Ctx, CtxOptions, input } from '../parser';
 import { some } from './some';
 import { reset, context } from './context';
 import { creation } from './context';
 
 describe('Unit: combinator/data/parser/context', () => {
-  interface Context extends Ctx {
+  interface Context extends CtxOptions {
     status?: boolean;
   }
 
   describe('reset', () => {
     const parser: Parser<number> = some(creation(1,
-      ({ source, context }) => [[context.resources?.clock ?? NaN], source.slice(1)]));
+      ({ context }) => {
+        context.position += 1;
+        return [[context.resources?.clock ?? NaN]];
+      }));
 
     it('root', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = {};
-      assert.deepStrictEqual(reset(base, parser)({ source: '123', context: ctx }), [[3, 2, 1], '']);
+      assert.deepStrictEqual(reset(base, parser)(input('123', ctx)), [[3, 2, 1]]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === undefined);
-      assert.throws(() => reset(base, parser)({ source: '1234', context: ctx }));
-      assert(ctx.resources?.clock === undefined);
-      assert.deepStrictEqual(reset(base, parser)({ source: '123', context: ctx }), [[3, 2, 1], '']);
+      assert.throws(() => reset(base, parser)(input('1234', ctx)));
+      assert(ctx.resources?.clock === 0);
     });
 
     it('node', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = { resources: { clock: 1, recursions: [1] } };
-      assert.deepStrictEqual(reset(base, parser)({ source: '1', context: ctx }), [[1], '']);
+      assert.deepStrictEqual(reset(base, parser)(input('1', ctx)), [[1]]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === 0);
-      assert.throws(() => reset(base, parser)({ source: '1', context: ctx }));
+      assert.throws(() => reset(base, parser)(input('1', ctx)));
       assert(ctx.resources?.clock === 0);
     });
 
   });
 
   describe('context', () => {
-    const parser: Parser<boolean, Context> = some(creation(1,
-      ({ source, context }) => [[context.status!], source.slice(1)]));
+    const parser: Parser<boolean, Context & Ctx> = some(creation(1,
+      ({ context }) => {
+        context.position += 1;
+        return [[context.status!]];
+      }));
 
     it('', () => {
       const base: Context = { status: true };
       const ctx: Context = { resources: { clock: 3, recursions: [1] } };
-      assert.deepStrictEqual(context(base, parser)({ source: '123', context: ctx }), [[true, true, true], '']);
+      assert.deepStrictEqual(context(base, parser)(input('123', ctx)), [[true, true, true]]);
       assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);
-      assert.throws(() => reset(base, parser)({ source: '1', context: ctx }));
+      assert.throws(() => reset(base, parser)(input('1', ctx)));
       assert(ctx.resources?.clock === 0);
-      assert(ctx.status === undefined);
+      assert(ctx.status === true);
     });
 
   });

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

@@ -1,57 +1,61 @@
-import { ObjectCreate, min } from 'spica/alias';
-import { Parser, Result, Ctx, Node, Context } from '../../data/parser';
+import { min } from 'spica/alias';
+import { Parser, Result, Ctx, CtxOptions, 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<P extends Parser<unknown>>(base: CtxOptions, parser: P): P;
 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);
   const values = Array(changes.length);
-  return ({ source, context }) =>
-    apply(parser, source, ObjectCreate(context), changes, values, true);
+  return ({ context }) =>
+    apply(parser, context, changes, values, true);
 }
 
-export function context<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
+export function context<P extends Parser<unknown>>(base: CtxOptions, parser: P): P;
 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);
   const values = Array(changes.length);
-  return ({ source, context }) =>
-    apply(parser, source, context, changes, values);
+  return ({ context }) =>
+    apply(parser, 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<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 = {};
-  }
+function apply<P extends Parser<unknown>>(parser: P, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Node<P>>;
+function apply<N>(parser: Parser<N>, context: Ctx, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<N> {
   for (let i = 0; i < changes.length; ++i) {
     const change = changes[i];
     const prop = change[0];
     switch (prop) {
+      case 'source':
+      case 'position':
+        continue;
       case 'resources':
         assert(reset);
         assert(!context.offset);
         assert(!context.precedence);
         assert(!context.delimiters);
         assert(!context.state);
+        values[i] = context[prop];
         context[prop as string] ??= clone({}, change[1] as object);
         continue;
+      case 'backtracks':
+        change[1] = {};
     }
     values[i] = context[prop];
     context[prop] = change[1];
   }
-  const result = parser({ source, context });
+  const result = parser({ context });
   for (let i = 0; i < changes.length; ++i) {
     const change = changes[i];
     const prop = change[0];
     switch (prop) {
+      case 'source':
+      case 'position':
+        continue;
       case 'resources':
         assert(reset);
-        // プロトタイプに戻ることで戻す
-        continue;
     }
     context[prop] = values[i];
     values[i] = undefined;