securemark 0.299.4 → 0.300.0

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

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

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

@@ -1,26 +0,0 @@
-import { Parser, Result, List, Node, Context } from '../../data/parser';
-
-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 input => {
-    const context = input;
-    const { source, position } = context;
-    if (position === source.length) return;
-    const res1 = parser(input);
-    if (res1 === undefined) {
-      context.position = position;
-      return;
-    }
-    context.range = context.position - position;
-    const res2 = f(res1, context);
-    if (res2 === undefined) {
-      context.position = position;
-      return;
-    }
-    return res2;
-  };
-}

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

@@ -1,10 +0,0 @@
-import { Parser, List, Node, Context } from '../../data/parser';
-import { bind } from './bind';
-
-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/parser/context.ts

@@ -1,96 +0,0 @@
-import { Parser, Context } from '../../data/parser';
-import { min } from 'spica/alias';
-
-export function creation<P extends Parser>(cost: number, parser: P): P;
-export function creation(cost: number, parser: Parser): Parser {
-  assert(cost >= 0);
-  return input => {
-    const context = input;
-    const result = parser(input);
-    if (result === undefined) return;
-    spend(context, cost);
-    return result;
-  };
-}
-export function spend(context: Context, cost: number): void {
-  const resources = context.resources ?? { clock: cost || 1, recursions: [1] };
-  if (resources.clock < cost) throw new Error('Too many creations');
-  resources.clock -= cost;
-}
-
-export function recursion<P extends Parser>(index: number, parser: P): P;
-export function recursion(index: number, parser: Parser): Parser {
-  assert(index >= 0);
-  return input => {
-    const context = input;
-    const resources = context.resources ?? { clock: 1, recursions: [1] };
-    const { recursions } = resources;
-    recur(recursions, index, 1);
-    const result = parser(input);
-    recur(recursions, index, -1);
-    return result;
-  };
-}
-export function recur(recursions: number[], index: number, size: number, force: boolean = false): void {
-  index = min(index, recursions.length && recursions.length - 1);
-  if (recursions[index] < size - +force) throw new Error('Too much recursion');
-  recursions[index] -= size;
-}
-
-export function precedence<P extends Parser>(precedence: number, parser: P): P;
-export function precedence<N>(precedence: number, parser: Parser<N>): Parser<N> {
-  assert(precedence >= 0);
-  return input => {
-    const context = input;
-    const { delimiters, precedence: p } = context;
-    const shift = delimiters && precedence > p;
-    context.precedence = precedence;
-    // デリミタはシフト後に設定しなければならない
-    shift && delimiters.shift(precedence);
-    const result = parser(input);
-    shift && delimiters.unshift();
-    context.precedence = p;
-    return result;
-  };
-}
-
-export function state<P extends Parser>(state: number, parser: P): P;
-export function state<P extends Parser>(state: number, positive: boolean, parser: P): P;
-export function state<N>(state: number, positive: boolean | Parser<N>, parser?: Parser<N>): Parser<N> {
-  if (typeof positive === 'function') {
-    parser = positive;
-    positive = true;
-  }
-  assert(state);
-  assert(parser = parser!);
-  return input => {
-    const context = input;
-    const s = context.state ?? 0;
-    context.state = positive
-      ? s | state
-      : s & ~state;
-    const result = parser(input);
-    context.state = s;
-    return result;
-  };
-}
-
-export function constraint<P extends Parser>(state: number, parser: P): P;
-//export function constraint<P extends Parser>(state: number, positive: boolean, parser: P): P;
-export function constraint<N>(state: number, positive: boolean | Parser<N>, parser?: Parser<N>): Parser<N> {
-  if (typeof positive === 'function') {
-    parser = positive;
-    positive = false;
-  }
-  assert(state);
-  assert(parser = parser!);
-  return input => {
-    const context = input;
-    const s = positive
-      ? state & context.state
-      : state & ~context.state;
-    return s === state
-      ? parser(input)
-      : undefined;
-  };
-}

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

@@ -1,20 +0,0 @@
-import { Parser, List, Node, Context } from '../parser';
-
-export function inits<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: 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, delimitation = false): 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<Node<N>> | undefined;
-    for (let len = parsers.length, i = 0; i < len; ++i) {
-      if (context.position === source.length) break;
-      if (delimitation && context.delimiters.test(input)) break;
-      const result = parsers[i](input);
-      if (result === undefined) break;
-      nodes = nodes?.import(result) ?? result;
-    }
-    return nodes;
-  };
-}

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

@@ -1,33 +0,0 @@
-import { Parser, List, Node, Context, input } from '../parser';
-import { sequence } from './sequence';
-import { inspect } from '../../../debug.test';
-
-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 Node('A')])
-        : undefined;
-    };
-    const b: Parser<string> = context => {
-      return context.source[context.position] === 'b'
-        ? void ++context.position || new List([new Node('B')])
-        : undefined;
-    };
-    const ab = sequence<Parser<string, Context, [typeof a, typeof b]>>([a, b]);
-
-    it('basic', () => {
-      const parser = ab;
-      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,20 +0,0 @@
-import { Parser, List, Node, Context, failsafe } from '../parser';
-
-export function sequence<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: 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, delimitation = false): Parser<N, Context, D> {
-  assert(parsers.every(f => f));
-  if (parsers.length === 1) return parsers[0];
-  return failsafe(input => {
-    const context = input;
-    const { source } = context;
-    let nodes: List<Node<N>> | undefined;
-    for (let len = parsers.length, i = 0; i < len; ++i) {
-      if (context.position === source.length) return;
-      if (delimitation && context.delimiters.test(input)) return;
-      const result = parsers[i](input);
-      if (result === undefined) return;
-      nodes = nodes?.import(result) ?? result;
-    }
-    return nodes;
-  });
-}

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

@@ -1,37 +0,0 @@
-import { Parser, List, Node, Context, input } from '../parser';
-import { union } from './union';
-import { some } from './some';
-import { inspect } from '../../../debug.test';
-
-describe('Unit: combinator/data/parser/some', () => {
-  describe('some', () => {
-    const a: Parser<string> = context => {
-      return context.source[context.position] === '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 Node('B')])
-        : undefined;
-    };
-    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('', 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']);
-    });
-
-  });
-
-});

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

@@ -1,41 +0,0 @@
-import { Parser, List, Node, Context, input } from '../parser';
-import { subsequence } from './subsequence';
-import { inspect } from '../../../debug.test';
-
-describe('Unit: combinator/data/parser/subsequence', () => {
-  describe('subsequence', () => {
-    const a: Parser<string> = context => {
-      return context.source[context.position] === '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 Node('B')])
-        : undefined;
-    };
-    const c: Parser<string> = context => {
-      return context.source[context.position] === 'c'
-        ? void ++context.position || new List([new Node('C')])
-        : undefined;
-    };
-    const abc = subsequence<Parser<string, Context, [typeof a, typeof b, typeof c]>>([a, b, c]);
-
-    it('basic', () => {
-      const parser = abc;
-      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('c', new Context())), [['C'], '']);
-      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'], 'ab']);
-      assert.deepStrictEqual(inspect(parser, input('abb', new Context())), [['A', 'B'], 'b']);
-      assert.deepStrictEqual(inspect(parser, input('bba', new Context())), [['B'], 'ba']);
-      assert.deepStrictEqual(inspect(parser, input('ac', new Context())), [['A', 'C'], '']);
-      assert.deepStrictEqual(inspect(parser, input('bc', new Context())), [['B', 'C'], '']);
-    });
-
-  });
-
-});

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

@@ -1,13 +0,0 @@
-import { Parser, Context } from '../parser';
-import { union } from './union';
-import { inits } from './inits';
-
-export function subsequence<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
-export function subsequence<N, D extends Parser<N>[]>(parsers: D, delimitation = false): Parser<N, Context, D> {
-  assert(parsers.every(f => f));
-  return union(
-    parsers.map((_, i) =>
-      i + 1 < parsers.length
-        ? inits([parsers[i], subsequence(parsers.slice(i + 1), delimitation)], delimitation)
-        : parsers[i]) as D);
-}

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

@@ -1,8 +0,0 @@
-import { Parser, Context } from '../parser';
-import { union } from './union';
-import { sequence } from './sequence';
-
-export function tails<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
-export function tails<N, D extends Parser<N>[]>(parsers: D, delimitation?: boolean): Parser<N, Context, D> {
-  return union(parsers.map((_, i) => sequence(parsers.slice(i), delimitation)) as D);
-}

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

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

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

@@ -1,18 +0,0 @@
-import { Parser, Context } from '../parser';
-
-export function union<P extends Parser>(parsers: Parser.SubParsers<P>): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
-export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context, D> {
-  assert(parsers.every(f => f));
-  switch (parsers.length) {
-    case 0:
-      return () => undefined;
-    case 1:
-      return parsers[0];
-    default:
-      return eval([
-        '(', parsers.map((_, i) => `parser${i},`).join(''), ') =>',
-        'input =>',
-        parsers.map((_, i) => `|| parser${i}(input)`).join('').slice(2),
-      ].join(''))(...parsers);
-  }
-}