securemark 0.295.0 → 0.295.2

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

@@ -1,54 +1,54 @@
-import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, failsafe } from '../../data/parser';
+import { Parser, Result, List, Node, Context, failsafe } from '../../data/parser';
 import { matcher, clear } from '../../../combinator';
 
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: Parser.IntermediateParser<P>, closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: false,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
-  f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>>, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: Parser.IntermediateParser<P>, closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
-  f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: false,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
-  f?: (rss: [List<Data<S>>, List<Data<Node<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
-  f?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser<string>, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: false,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
-  f?: (rss: [List<Data<S>>, List<Data<Node<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<P extends Parser<string>, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Context<P>>,
+  opener: string | RegExp | Parser<S, Parser.Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Parser.Context<P>>,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
-  f?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>,
 ): P;
 export function surround<N>(
   opener: string | RegExp | Parser<N>, parser: string | RegExp | Parser<N>, closer: string | RegExp | Parser<N>,
   optional: boolean = false,
-  backtracks: readonly [] | readonly [number] | readonly [number, number] = [],
-  f?: (rss: [List<Data<N>>, List<Data<N>>, List<Data<N>>], context: Ctx) => Result<N>,
-  g?: (rss: [List<Data<N>>, List<Data<N>> | undefined], context: Ctx) => Result<N>,
+  backtracks: readonly number[] = [],
+  f?: (rss: [List<Node<N>>, List<Node<N>>, List<Node<N>>], context: Context) => Result<N>,
+  g?: (rss: [List<Node<N>>, List<Node<N>> | undefined], context: Context) => Result<N>,
 ): Parser<N> {
   switch (typeof opener) {
     case 'string':
@@ -68,7 +68,7 @@ export function surround<N>(
       closer = clear(matcher(closer, true));
   }
   assert(closer);
-  const [rbs, wbs] = reduce(backtracks);
+  const [blen, rbs, wbs] = reduce(backtracks);
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
@@ -79,7 +79,7 @@ export function surround<N>(
     if (!nodesO) {
       return void revert(context, linebreak);
     }
-    if (rbs && isBacktrack(context, rbs, position, context.position - position || 1)) {
+    if (rbs && isBacktrack(context, rbs, position, blen)) {
       return void revert(context, linebreak);
     }
     const nodesM = context.position < source.length ? parser(input) : undefined;
@@ -110,98 +110,98 @@ export function surround<N>(
   });
 }
 export function open<P extends Parser>(
-  opener: string | RegExp | Parser<Node<P>, Context<P>>,
+  opener: string | RegExp | Parser<Parser.Node<P>, Parser.Context<P>>,
   parser: P,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
+  backtracks?: readonly number[],
 ): P;
 export function open<P extends Parser<string>>(
-  opener: string | RegExp | Parser<Node<P>, Context<P>>,
+  opener: string | RegExp | Parser<Parser.Node<P>, Parser.Context<P>>,
   parser: string | RegExp | P,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
+  backtracks?: readonly number[],
 ): P;
 export function open<N>(
-  opener: string | RegExp | Parser<N, Ctx>,
+  opener: string | RegExp | Parser<N, Context>,
   parser: string | RegExp | Parser<N>,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
+  backtracks: readonly number[] = [],
 ): Parser<N> {
   return surround(opener, parser as Parser<N>, '', optional, backtracks);
 }
 export function close<P extends Parser>(
   parser: P,
-  closer: string | RegExp | Parser<Node<P>, Context<P>>,
+  closer: string | RegExp | Parser<Parser.Node<P>, Parser.Context<P>>,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
+  backtracks?: readonly number[],
 ): P;
 export function close<P extends Parser<string>>(
   parser: string | RegExp | P,
-  closer: string | RegExp | Parser<Node<P>, Context<P>>,
+  closer: string | RegExp | Parser<Parser.Node<P>, Parser.Context<P>>,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
+  backtracks?: readonly number[],
 ): P;
 export function close<N>(
   parser: string | RegExp | Parser<N>,
-  closer: string | RegExp | Parser<N, Ctx>,
+  closer: string | RegExp | Parser<N, Context>,
   optional?: boolean,
-  backtracks?: readonly [] | readonly [number] | readonly [number, number],
+  backtracks: readonly number[] = [],
 ): Parser<N> {
   return surround('', parser as Parser<N>, closer, optional, backtracks);
 }
 
 const commandsize = 2;
 export function isBacktrack(
-  context: Ctx,
+  context: Context,
   backtrack: number,
   position: number = context.position,
   length: number = 1,
 ): boolean {
-  assert(backtrack & 1);
-  if (length === 0) return false;
-  const { source } = context;
-  if (position === source.length) return false;
-  const { backtracks = {}, offset = 0 } = context;
+  assert(1 & backtrack);
+  assert(backtrack >>> commandsize);
+  assert(0 < length && length < 3);
+  const { backtracks, offset } = context;
   for (let i = 0; i < length; ++i) {
-    if (position + i === source.length) break;
-    if (i > 0 && source[position + i] !== source[position]) break;
-    const pos = position + i + offset;
-    if (backtracks[pos] & backtrack >>> commandsize) return true;
+    if (backtracks[position + i + offset] & backtrack >>> commandsize) return true;
   }
   return false;
 }
 export function setBacktrack(
-  context: Ctx,
+  context: Context,
   backtrack: number,
   position: number,
   length: number = 1,
 ): void {
   // バックトラックの可能性がなく記録不要の場合もあるが判別が面倒なので省略
-  assert(backtrack & 2);
-  if (length === 0) return;
-  const { source } = context;
-  if (position === source.length) return;
-  const { backtracks = {}, offset = 0 } = context;
+  assert(2 & backtrack);
+  assert(backtrack >>> commandsize);
+  assert(0 < length && length < 3);
+  const { backtracks, offset } = context;
   for (let i = 0; i < length; ++i) {
-    if (position + i === source.length) break;
-    const pos = position + i + offset;
-    backtracks[pos] |= backtrack >>> commandsize;
+    backtracks[position + i + offset] |= backtrack >>> commandsize;
   }
 }
-function reduce(backtracks: readonly number[]): readonly [number, number] {
+function reduce(backtracks: readonly number[]): readonly [number, number, number] {
+  let len = 1;
   let rbs = 0;
   let wbs = 0;
   for (const backtrack of backtracks) {
-    if (backtrack & 1) {
+    if (backtrack >>> commandsize === 0) {
+      len = backtrack;
+      assert(len > 0);
+      continue;
+    }
+    assert(backtrack >>> commandsize);
+    if (1 & backtrack) {
       rbs |= backtrack;
     }
-    if (backtrack & 2) {
+    if (2 & backtrack) {
       wbs |= backtrack;
     }
   }
-  return [rbs, wbs];
+  return [len, rbs, wbs];
 }
 
-function revert(context: Ctx, linebreak: number | undefined): void {
+function revert(context: Context, linebreak: number): void {
   context.linebreak = linebreak;
 }

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

@@ -1,10 +1,10 @@
-import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, failsafe } from '../../data/parser';
+import { Parser, Result, List, Node, Context, failsafe } from '../../data/parser';
 
-export function bind<P extends Parser>(parser: IntermediateParser<P>, f: (nodes: List<Data<SubNode<P>>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
-export function bind<P extends Parser>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
-export function bind<N, P extends Parser>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: List<Data<N>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
-export function bind<U, P extends Parser>(parser: P, f: (nodes: List<Data<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: List<Data<N>>, context: Ctx) => Result<U>): Parser<U> {
+export function bind<P extends Parser>(parser: Parser.IntermediateParser<P>, f: (nodes: List<Node<Parser.SubNode<P>>>, context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>): P;
+export function bind<P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>): P;
+export function bind<N, P extends Parser>(parser: Parser<N, Parser.Context<P>, Parser.SubParsers<P>>, f: (nodes: List<Node<N>>, context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>): P;
+export function bind<U, P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => Result<U, Parser.Context<P>, Parser.SubParsers<P>>): Parser<U, Parser.Context<P>, Parser.SubParsers<P>>;
+export function bind<N, U>(parser: Parser<N>, f: (nodes: List<Node<N>>, context: Context) => Result<U>): Parser<U> {
   assert(parser);
   return failsafe(input => {
     const { context } = input;

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

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

package/src/combinator/data/data.ts

@@ -1,6 +1,6 @@
-import { Parser, Ctx } from './parser';
+import { Parser, Context } from './parser';
 
-export class List<N extends List.Node = List.Node, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any> {
+export class List<N extends List.Node = List.Node, C extends Context = Context, D extends Parser<unknown, C>[] = any> {
   constructor(nodes?: ArrayLike<N>) {
     if (nodes === undefined) return;
     for (let i = 0; i < nodes.length; ++i) {

package/src/combinator/data/{parser/context/delimiter.ts → delimiter.ts}

@@ -1,5 +1,5 @@
-import { Input, Ctx } from '../../parser';
-import { matcher } from '../../../../combinator';
+import { Input, Context } from './parser';
+import { matcher } from '../../combinator';
 
 interface Delimiter {
   readonly memory: Delimiter[];
@@ -27,7 +27,7 @@ export class Delimiters {
         return `r/${pattern.source}`;
     }
   }
-  public static matcher(pattern: string | RegExp | undefined): (input: Input<Ctx>) => true | undefined {
+  public static matcher(pattern: string | RegExp | undefined): (input: Input<Context>) => true | undefined {
     switch (typeof pattern) {
       case 'undefined':
         return () => undefined;
@@ -130,7 +130,7 @@ export class Delimiters {
     }
   }
   public match(input: Input): boolean {
-    const { precedence = 0 } = input.context;
+    const { precedence } = input.context;
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];

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

@@ -1,23 +1,24 @@
-import { Parser, List, Data, Ctx, CtxOptions, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { some } from './some';
 import { reset, context, creation } from './context';
 import { unwrap } from '../../../parser/util';
 
 describe('Unit: combinator/data/parser/context', () => {
-  interface Context extends CtxOptions {
+  interface Ctx extends Context {
     status?: boolean;
   }
+  type Opts = Partial<Ctx>;
 
   describe('reset', () => {
     const parser: Parser<number> = some(creation(1,
       ({ context }) => {
         context.position += 1;
-        return new List([new Data(context.resources?.clock ?? NaN)]);
+        return new List([new Node(context.resources?.clock ?? NaN)]);
       }));
 
     it('root', () => {
-      const base: Context = { resources: { clock: 3, recursions: [1] } };
-      const ctx: Context = {};
+      const base: Opts = { resources: { clock: 3, recursions: [1] } };
+      const ctx: Ctx = new Context();
       assert.deepStrictEqual([...unwrap(reset(base, parser)(input('123', ctx))!)], [3, 2, 1]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === undefined);
@@ -26,8 +27,8 @@ describe('Unit: combinator/data/parser/context', () => {
     });
 
     it('node', () => {
-      const base: Context = { resources: { clock: 3, recursions: [1] } };
-      const ctx: Context = { resources: { clock: 2, recursions: [1] } };
+      const base: Opts = { resources: { clock: 3, recursions: [1] } };
+      const ctx: Ctx = new Context({ resources: { clock: 2, recursions: [1] } });
       assert.deepStrictEqual([...unwrap(reset(base, parser)(input('1', ctx))!)], [2]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === 1);
@@ -38,15 +39,15 @@ describe('Unit: combinator/data/parser/context', () => {
   });
 
   describe('context', () => {
-    const parser: Parser<boolean, Context & Ctx> = some(creation(1,
+    const parser: Parser<boolean, Ctx & Ctx> = some(creation(1,
       ({ context }) => {
         context.position += 1;
-        return new List([new Data(context.status!)]);
+        return new List([new Node(context.status!)]);
       }));
 
     it('', () => {
-      const base: Context = { status: true };
-      const ctx: Context = { resources: { clock: 2, recursions: [1] } };
+      const base: Opts = { status: true };
+      const ctx: Ctx = new Context({ resources: { clock: 2, recursions: [1] } });
       assert.deepStrictEqual([...unwrap(context(base, parser)(input('1', ctx))!)], [true]);
       assert(base.resources?.clock === undefined);
       assert(ctx.resources?.clock === 1);

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

@@ -1,9 +1,9 @@
+import { Parser, Result, List, Node, Context, Options } from '../../data/parser';
 import { min } from 'spica/alias';
-import { Parser, Result, List, Data, Ctx, CtxOptions, Node, Context } from '../../data/parser';
 import { clone } from 'spica/assign';
 
-export function reset<P extends Parser>(base: CtxOptions, parser: P): P;
-export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
+export function reset<P extends Parser>(base: Options, parser: P): P;
+export function reset<N>(base: Context, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -13,8 +13,8 @@ export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
     apply(parser, { ...context }, changes, values, true);
 }
 
-export function context<P extends Parser>(base: CtxOptions, parser: P): P;
-export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
+export function context<P extends Parser>(base: Options, parser: P): P;
+export function context<N>(base: Context, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -23,8 +23,8 @@ export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
     apply(parser, context, changes, values);
 }
 
-function apply<P extends Parser>(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> {
+function apply<P extends Parser>(parser: P, context: Parser.Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Parser.Node<P>>;
+function apply<N>(parser: Parser<N>, context: Context, 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];
@@ -36,7 +36,6 @@ function apply<N>(parser: Parser<N>, context: Ctx, changes: readonly [string, un
         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);
@@ -78,7 +77,7 @@ export function creation(cost: number, parser: Parser): Parser {
     return result;
   };
 }
-export function consume(cost: number, context: Ctx): void {
+export function consume(cost: number, context: Context): void {
   const { resources } = context;
   if (!resources) return;
   if (resources.clock < cost) throw new Error('Too many creations');
@@ -107,7 +106,7 @@ export function precedence<N>(precedence: number, parser: Parser<N>): Parser<N>
   assert(precedence >= 0);
   return input => {
     const { context } = input;
-    const { delimiters, precedence: p = 0 } = context;
+    const { delimiters, precedence: p } = context;
     const shift = delimiters && precedence > p;
     context.precedence = precedence;
     // デリミタはシフト後に設定しなければならない
@@ -152,8 +151,8 @@ export function constraint<N>(state: number, positive: boolean | Parser<N>, pars
   return input => {
     const { context } = input;
     const s = positive
-      ? state & context.state!
-      : state & ~context.state!;
+      ? state & context.state
+      : state & ~context.state;
     return s === state
       ? parser(input)
       : undefined;
@@ -173,7 +172,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
         if (advance) {
           context.position += pattern.length;
         }
-        return new List([new Data(pattern)]);
+        return new List([new Node(pattern)]);
       };
     case 'object':
       assert(pattern.sticky);
@@ -186,7 +185,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
         if (advance) {
           context.position += src.length;
         }
-        return new List([new Data(src)]);
+        return new List([new Node(src)]);
       };
   }
 }

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

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

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { sequence } from './sequence';
 import { inspect } from '../../../debug.test';
 
@@ -6,27 +6,26 @@ describe('Unit: combinator/data/parser/sequence', () => {
   describe('sequence', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || new List([new Data('A')])
+        ? void ++context.position || new List([new Node('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || new List([new Data('B')])
+        ? void ++context.position || new List([new Node('B')])
         : undefined;
     };
-    const ab = sequence<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
-    const { context: ctx } = input('', {});
+    const ab = sequence<Parser<string, Context, [typeof a, typeof b]>>([a, b]);
 
     it('basic', () => {
       const parser = ab;
-      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);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ba', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('aab', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('abb', new Context())), [['A', 'B'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('bba', new Context())), undefined);
     });
 
   });

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

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

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { union } from './union';
 import { some } from './some';
 import { inspect } from '../../../debug.test';
@@ -7,30 +7,29 @@ describe('Unit: combinator/data/parser/some', () => {
   describe('some', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || new List([new Data('A')])
+        ? void ++context.position || new List([new Node('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || new List([new Data('B')])
+        ? void ++context.position || new List([new Node('B')])
         : undefined;
     };
-    const ab = union<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
-    const { context: ctx } = input('', {});
+    const ab = union<Parser<string, Context, [typeof a, typeof b]>>([a, b]);
 
     it('basic', () => {
       const parser = some(ab, /aaa/y);
-      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']);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('b', new Context())), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ba', new Context())), [['B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aab', new Context())), [['A', 'A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('bba', new Context())), [['B', 'B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aaa', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('bbb', new Context())), [['B', 'B', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aaab', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('baaa', new Context())), [['B'], 'aaa']);
     });
 
   });