securemark 0.295.1 → 0.295.2

package/markdown.d.ts

@@ -1,32 +1,17 @@
-import { Parser, List, Data, Ctx, CtxOptions } from './src/combinator/data/parser';
-import { Dict } from 'spica/dict';
+import { Parser, List, Node } from './src/combinator/data/parser';
+import { Context } from './src/parser/context';
 
 declare abstract class Markdown<T> {
   private parser?: T;
 }
 export interface MarkdownParser extends
   Markdown<'markdown'>,
-  Parser<DocumentFragment, MarkdownParser.Context, [
+  Parser<DocumentFragment, Context, [
     MarkdownParser.HeaderParser,
     MarkdownParser.BlockParser,
   ]> {
 }
 export namespace MarkdownParser {
-  export interface Context extends Ctx, Options {
-    buffer?: List<Data<(string | HTMLElement)>>;
-    sequential?: boolean;
-  }
-  export interface Options extends CtxOptions {
-    readonly host?: URL;
-    readonly url?: URL;
-    readonly id?: string;
-    readonly header?: boolean;
-    readonly caches?: {
-      readonly code?: Dict<string, HTMLElement>;
-      readonly math?: Dict<string, HTMLElement>;
-      readonly media?: Dict<string, HTMLElement>;
-    };
-  }
   export interface SegmentParser extends
     Markdown<'segment'>,
     Parser<string, Context, [
@@ -434,7 +419,7 @@ export namespace MarkdownParser {
         }
         export interface RowParser extends
           Block<'extension/table/row'>,
-          Parser<List<Data<[string[], string[]?] | HTMLTableCellElement>>, Context, [
+          Parser<List<Node<[string[], string[]?] | HTMLTableCellElement>>, Context, [
             Parser<[string[], string[]?], Context, [
               AlignParser,
             ]>,
@@ -791,7 +776,7 @@ export namespace MarkdownParser {
       export interface TextLinkParser extends
         Inline<'link/textlink'>,
         Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
-          Parser<List<Data<string | HTMLElement>>, Context, [
+          Parser<List<Node<string | HTMLElement>>, Context, [
             InlineParser,
           ]>,
           LinkParser.ParameterParser,
@@ -800,7 +785,7 @@ export namespace MarkdownParser {
       export interface MediaLinkParser extends
         Inline<'link/medialink'>,
         Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
-          Parser<List<Data<HTMLElement>>, Context, [
+          Parser<List<Node<HTMLElement>>, Context, [
             MediaParser,
             ShortMediaParser,
           ]>,
@@ -809,7 +794,7 @@ export namespace MarkdownParser {
       }
       export interface ContentParser extends
         Inline<'link/content'>,
-        Parser<List<Data<string | HTMLElement>>, Context, [
+        Parser<List<Node<string | HTMLElement>>, Context, [
           MediaParser,
           ShortMediaParser,
           InlineParser,
@@ -817,13 +802,13 @@ export namespace MarkdownParser {
       }
       export interface TextParser extends
         Inline<'link/text'>,
-        Parser<List<Data<string>>, Context, [
+        Parser<List<Node<string>>, Context, [
           SourceParser.UnescapableSourceParser,
         ]> {
       }
       export interface ParameterParser extends
         Inline<'link/parameter'>,
-        Parser<List<Data<string>>, Context, [
+        Parser<List<Node<string>>, Context, [
           LinkParser.ParameterParser.UriParser,
           LinkParser.ParameterParser.OptionParser,
         ]> {
@@ -858,7 +843,7 @@ export namespace MarkdownParser {
     export namespace MediaParser {
       export interface TextParser extends
         Inline<'media/text'>,
-        Parser<List<Data<string>>, Context, [
+        Parser<List<Node<string>>, Context, [
           UnsafeHTMLEntityParser,
           TextParser.BracketParser,
           SourceParser.TxtParser,
@@ -892,7 +877,7 @@ export namespace MarkdownParser {
       }
       export interface ParameterParser extends
         Inline<'media/parameter'>,
-        Parser<List<Data<string>>, Context, [
+        Parser<List<Node<string>>, Context, [
           LinkParser.ParameterParser.UriParser,
           ParameterParser.OptionParser,
         ]> {
@@ -911,8 +896,8 @@ export namespace MarkdownParser {
       // [AB](a b)
       Inline<'ruby'>,
       Parser<HTMLElement, Context, [
-        Parser<List<Data<string>>, Context, []>,
-        Parser<List<Data<string>>, Context, []>,
+        Parser<List<Node<string>>, Context, []>,
+        Parser<List<Node<string>>, Context, []>,
       ]> {
     }
     export namespace RubyParser {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.295.1",
+  "version": "0.295.2",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/combinator/control/constraint/block.test.ts

@@ -1,20 +1,18 @@
 import { block } from './block';
-import { List, Data, input } from '../../data/parser';
+import { List, Node, Context, input } from '../../data/parser';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/block', () => {
   describe('block', () => {
-    const { context: ctx } = input('', {});
-
     it('invalid', () => {
-      assert.throws(() => block(_ => new List<Data<string>>())(input(' \n', ctx)));
+      assert.throws(() => block(_ => new List<Node<string>>())(input(' \n', new Context())));
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input(' \n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n\n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length - 1; return new List<Data<string>>(); })(input('\n\n', ctx)), ctx), [[], '\n']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Node<string>>(); }), input('\n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Node<string>>(); }), input(' \n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Node<string>>(); }), input('\n\n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length - 1; return new List<Node<string>>(); }), input('\n\n', new Context())), [[], '\n']);
     });
 
   });

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

@@ -1,4 +1,4 @@
-import { Parser, Input, List, Data, Ctx, Node, Context, failsafe } from '../../data/parser';
+import { Parser, Input, List, Node, Context, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
 //export function contract<P extends Parser>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
@@ -7,8 +7,8 @@ import { matcher } from '../../../combinator';
 //}
 
 export function validate<P extends Parser>(pattern: string | RegExp, parser: P): P;
-export function validate<P extends Parser>(cond: ((input: Input<Context<P>>) => boolean), parser: P): P;
-export function validate<N>(pattern: string | RegExp | ((input: Input<Ctx>) => boolean), parser: Parser<N>): Parser<N> {
+export function validate<P extends Parser>(cond: ((input: Input<Parser.Context<P>>) => boolean), parser: P): P;
+export function validate<N>(pattern: string | RegExp | ((input: Input<Context>) => boolean), parser: Parser<N>): Parser<N> {
   if (typeof pattern === 'function') return guard(pattern, parser);
   const match = matcher(pattern, false);
   return input => {
@@ -20,16 +20,16 @@ export function validate<N>(pattern: string | RegExp | ((input: Input<Ctx>) => b
   };
 }
 
-function guard<P extends Parser>(f: (input: Input<Context<P>>) => boolean, parser: P): P;
-function guard<N>(f: (input: Input<Ctx>) => boolean, parser: Parser<N>): Parser<N> {
+function guard<P extends Parser>(f: (input: Input<Parser.Context<P>>) => boolean, parser: P): P;
+function guard<N>(f: (input: Input<Context>) => boolean, parser: Parser<N>): Parser<N> {
   return input =>
     f(input)
       ? parser(input)
       : undefined;
 }
 
-export function verify<P extends Parser>(parser: P, cond: (nodes: List<Data<Node<P>>>, context: Context<P>) => boolean): P;
-export function verify<N>(parser: Parser<N>, cond: (nodes: List<Data<N>>, context: Ctx) => boolean): Parser<N> {
+export function verify<P extends Parser>(parser: P, cond: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => boolean): P;
+export function verify<N>(parser: Parser<N>, cond: (nodes: List<Node<N>>, context: Context) => boolean): Parser<N> {
   assert(parser);
   return failsafe(input => {
     const { context } = input;

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

@@ -1,21 +1,19 @@
-import { List, Data, input } from '../../data/parser';
+import { List, Node, Context, input } from '../../data/parser';
 import { line } from './line';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/line', () => {
   describe('line', () => {
-    const { context: ctx } = input('', {});
-
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(line(_ => new List<Data<string>>())(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(line(_ => new List<Node<string>>()), input('', new Context())), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input(' ', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n\n', ctx)), ctx), [[], '\n']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input(' \n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length - 1; return new List<Data<string>>(); })(input(' \n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Node<string>>(); }), input(' ', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Node<string>>(); }), input('\n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Node<string>>(); }), input('\n\n', new Context())), [[], '\n']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Node<string>>(); }), input(' \n', new Context())), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length - 1; return new List<Node<string>>(); }), input(' \n', new Context())), [[], '']);
     });
 
   });

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

@@ -7,7 +7,6 @@ export function line<N>(parser: Parser<N>): Parser<N> {
     const { source, position } = context;
     if (position === source.length) return;
     const line = firstline(source, position);
-    context.offset ??= 0;
     context.offset += position;
     const result = parser(input(line, context));
     context.position += position;

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

@@ -1,5 +1,5 @@
-import { Parser, List, Ctx } from '../../data/parser';
+import { Parser, List, Context } from '../../data/parser';
 
-export function clear<D extends Parser<unknown, C>[], C extends Ctx>(parser: Parser<unknown, C, D>): Parser<never, C, D> {
+export function clear<D extends Parser<unknown, C>[], C extends Context>(parser: Parser<unknown, C, D>): Parser<never, C, D> {
   return input => parser(input) && new List();
 }

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

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

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

@@ -1,7 +1,7 @@
-import { Parser, List, Data, Ctx } from '../../data/parser';
+import { Parser, List, Node, Context } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 
-export function dup<N, C extends Ctx, D extends Parser<unknown, C>[]>(parser: Parser<N, C, D>): Parser<List<Data<N>>, C, D>;
-export function dup<N>(parser: Parser<N>): Parser<List<Data<N>>> {
-  return fmap(parser, nodes => new List([new Data(nodes)]));
+export function dup<N, C extends Context, D extends Parser<unknown, C>[]>(parser: Parser<N, C, D>): Parser<List<Node<N>>, C, D>;
+export function dup<N>(parser: Parser<N>): Parser<List<Node<N>>> {
+  return fmap(parser, nodes => new List([new Node(nodes)]));
 }

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

@@ -1,7 +1,7 @@
-import { Parser, Node, Context } from '../../data/parser';
+import { Parser } from '../../data/parser';
 import { union } from '../../data/parser/union';
 
-export function fallback<P extends Parser>(parser: P, otherwise: Parser<Node<P>, Context<P>>): P;
+export function fallback<P extends Parser>(parser: P, otherwise: Parser<Parser.Node<P>, Parser.Context<P>>): P;
 export function fallback<N>(parser: Parser<N>, otherwise: Parser<N>): Parser<N> {
   return union([parser, otherwise]);
 }

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

@@ -1,9 +1,9 @@
-import { Parser, List, Data, Ctx, failsafe } from '../../data/parser';
+import { Parser, List, Node, Context, failsafe } from '../../data/parser';
 import { consume } from '../../../combinator';
 import { firstline, isBlankline } from '../constraint/line';
 import { push } from 'spica/array';
 
-export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation = true): Parser<string, C, D> {
+export function fence<C extends Context, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation = true): Parser<string, C, D> {
   assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
   return failsafe(input => {
     const { context } = input;
@@ -49,6 +49,6 @@ export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: Reg
       }
       context.position += line.length;
     }
-    return new List(push([block, overflow, closer], matches).map(str => new Data(str)));
+    return new List(push([block, overflow, closer], matches).map(str => new Node(str)));
   });
 }

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

@@ -1,31 +1,29 @@
 import { indent } from './indent';
-import { List, Data, input } from '../../data/parser';
+import { List, Node, Context, input } from '../../data/parser';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/indent', () => {
   describe('indent', () => {
-    const { context: ctx } = input('', {});
-
     it('valid', () => {
-      const parser = indent(({ context }) => { context.position = context.source.length; return new List([new Data(context.source)]); });
-      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input(' ', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('  ', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('a ', ctx)), ctx), undefined);
-      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', 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', ctx)), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(input('     a', ctx)), ctx), [[' a'], '']);
-      assert.deepStrictEqual(inspect(parser(input(' a\n a', ctx)), ctx), [['a\na'], '']);
-      assert.deepStrictEqual(inspect(parser(input(' a\n  a', ctx)), ctx), [['a\n a'], '']);
-      assert.deepStrictEqual(inspect(parser(input('    a\n        a', ctx)), ctx), [['a\n    a'], '']);
-      assert.deepStrictEqual(inspect(parser(input('  a\n a', ctx)), ctx), [['a'], ' a']);
-      assert.deepStrictEqual(inspect(parser(input(' \ta', ctx)), ctx), [['\ta'], '']);
-      assert.deepStrictEqual(inspect(parser(input('\ta', ctx)), ctx), [['a'], '']);
+      const parser = indent(({ context }) => { context.position = context.source.length; return new List([new Node(context.source)]); });
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('  ', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a ', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a ', new Context())), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a \n', new Context())), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser, input('  a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('   a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('    a', new Context())), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('     a', new Context())), [[' a'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n a', new Context())), [['a\na'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n  a', new Context())), [['a\n a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('    a\n        a', new Context())), [['a\n    a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  a\n a', new Context())), [['a'], ' a']);
+      assert.deepStrictEqual(inspect(parser, input(' \ta', new Context())), [['\ta'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\ta', new Context())), [['a'], '']);
     });
 
   });

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, subinput, failsafe } from '../../data/parser';
+import { Parser, List, Node, subinput, failsafe } from '../../data/parser';
 import { some } from '../../data/parser/some';
 import { block } from '../constraint/block';
 import { line } from '../constraint/line';
@@ -24,7 +24,7 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
       some(line(open(indent, ({ context }) => {
         const { source, position } = context;
         context.position = source.length;
-        return new List([new Data(source.slice(position))]);
+        return new List([new Node(source.slice(position))]);
       }))),
     ([indent]) => indent.length * 2 + -(indent[0] === ' '), [], 2 ** 4 - 1)), separation),
     (lines, context) =>

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

@@ -1,7 +1,7 @@
-import { Parser, Input, Result, Ctx, Node, Context } from '../../data/parser';
+import { Parser, Input, Result, Context } from '../../data/parser';
 
-export function recover<P extends Parser>(parser: P, fallback: (input: Input<Context<P>>, reason: unknown) => Result<Node<P>>): P;
-export function recover<N>(parser: Parser<N>, fallback: (input: Input<Ctx>, reason: unknown) => Result<N>): Parser<N> {
+export function recover<P extends Parser>(parser: P, fallback: (input: Input<Parser.Context<P>>, reason: unknown) => Result<Parser.Node<P>>): P;
+export function recover<N>(parser: Parser<N>, fallback: (input: Input<Context>, reason: unknown) => Result<N>): Parser<N> {
   return input => {
     const { context } = input;
     const { source, position } = context;

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

@@ -1,8 +1,8 @@
-import { Parser, List, Data } from '../../data/parser';
+import { Parser, List, Node } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 
 export function reverse<P extends Parser>(parser: P): P;
 export function reverse<N>(parser: Parser<N>): Parser<N> {
-  return fmap(parser, nodes => nodes.foldr((node, acc) => acc.push(nodes.delete(node)) && acc, new List<Data<N>>()));
+  return fmap(parser, nodes => nodes.foldr((node, acc) => acc.push(nodes.delete(node)) && acc, new List<Node<N>>()));
 }
 

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

@@ -1,4 +1,4 @@
-import { Parser, Context, input, failsafe } from '../../data/parser';
+import { Parser, input, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
 export function focus<P extends Parser>(scope: string | RegExp, parser: P, slice?: boolean): P;
@@ -18,7 +18,6 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true
       context.position += result && context.position === position ? range : 0;
       return result;
     }
-    context.offset ??= 0;
     context.offset += position;
     const result = parser(input(src, context));
     context.position += position;
@@ -30,7 +29,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true
 }
 
 //export function rewrite<N, C extends Ctx, D extends Parser<unknown, C>[]>(scope: Parser<unknown, C, D>, parser: Parser<N, C, never>): Parser<N, C, D>;
-export function rewrite<P extends Parser>(scope: Parser<unknown, Context<P>>, parser: P, slice?: boolean): P;
+export function rewrite<P extends Parser>(scope: Parser<unknown, Parser.Context<P>>, parser: P, slice?: boolean): P;
 export function rewrite<N>(scope: Parser, parser: Parser<N>, slice = true): Parser<N> {
   assert(scope);
   assert(parser);
@@ -51,7 +50,6 @@ export function rewrite<N>(scope: Parser, parser: Parser<N>, slice = true): Pars
     const src = source.slice(position, context.position);
     assert(src !== '');
     assert(source.startsWith(src, position));
-    context.offset ??= 0;
     context.offset += position;
     const res2 = parser(input(src, context));
     context.position += position;

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 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>>,
+  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 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>>,
+  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 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>>,
+  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 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>>,
+  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 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>>,
+  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 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>>,
+  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 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>,
+  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':
@@ -110,19 +110,19 @@ 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 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 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 number[] = [],
@@ -131,19 +131,19 @@ export function open<N>(
 }
 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 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 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 number[] = [],
 ): Parser<N> {
@@ -152,7 +152,7 @@ export function close<N>(
 
 const commandsize = 2;
 export function isBacktrack(
-  context: Ctx,
+  context: Context,
   backtrack: number,
   position: number = context.position,
   length: number = 1,
@@ -160,14 +160,14 @@ export function isBacktrack(
   assert(1 & backtrack);
   assert(backtrack >>> commandsize);
   assert(0 < length && length < 3);
-  const { backtracks = {}, offset = 0 } = context;
+  const { backtracks, offset } = context;
   for (let i = 0; i < length; ++i) {
     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,
@@ -176,7 +176,7 @@ export function setBacktrack(
   assert(2 & backtrack);
   assert(backtrack >>> commandsize);
   assert(0 < length && length < 3);
-  const { backtracks = {}, offset = 0 } = context;
+  const { backtracks, offset } = context;
   for (let i = 0; i < length; ++i) {
     backtracks[position + i + offset] |= backtrack >>> commandsize;
   }
@@ -202,6 +202,6 @@ function reduce(backtracks: readonly number[]): readonly [number, number, number
   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;