securemark 0.257.2 → 0.258.1

package/markdown.d.ts

@@ -17,17 +17,6 @@ export namespace MarkdownParser {
     readonly url?: URL;
     readonly id?: string;
     readonly header?: boolean;
-    readonly syntax?: {
-      readonly inline?: {
-        readonly annotation?: boolean;
-        readonly reference?: boolean;
-        readonly index?: boolean;
-        readonly label?: boolean;
-        readonly link?: boolean;
-        readonly media?: boolean;
-        readonly autolink?: boolean;
-      };
-    };
     readonly caches?: {
       readonly code?: Dict<string, HTMLElement>;
       readonly math?: Dict<string, HTMLElement>;
@@ -700,7 +689,7 @@ export namespace MarkdownParser {
     export interface TemplateParser extends
       // {{abc}}
       Inline<'template'>,
-      Parser<HTMLSpanElement, Context, [
+      Parser<HTMLSpanElement | string, Context, [
         TemplateParser.BracketParser,
         SourceParser.EscapableSourceParser,
       ]> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.257.2",
+  "version": "0.258.1",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -34,13 +34,13 @@
     "@types/mocha": "9.1.1",
     "@types/power-assert": "1.5.8",
     "@types/prismjs": "1.26.0",
-    "@typescript-eslint/parser": "^5.28.0",
+    "@typescript-eslint/parser": "^5.29.0",
     "babel-loader": "^8.2.5",
     "babel-plugin-unassert": "^3.2.0",
     "concurrently": "^7.2.2",
-    "eslint": "^8.17.0",
+    "eslint": "^8.18.0",
     "eslint-plugin-redos": "^4.4.1",
-    "eslint-webpack-plugin": "^3.1.1",
+    "eslint-webpack-plugin": "^3.2.0",
     "glob": "^8.0.3",
     "karma": "^6.4.0",
     "karma-chrome-launcher": "^3.1.1",
@@ -49,12 +49,12 @@
     "karma-mocha": "^2.0.1",
     "karma-power-assert": "^1.0.0",
     "mocha": "^10.0.0",
-    "npm-check-updates": "^14.0.1",
+    "npm-check-updates": "^14.1.1",
     "semver": "^7.3.7",
-    "spica": "0.0.570",
-    "ts-loader": "^9.3.0",
-    "typed-dom": "^0.0.299",
-    "typescript": "4.7.3",
+    "spica": "0.0.573",
+    "ts-loader": "^9.3.1",
+    "typed-dom": "^0.0.301",
+    "typescript": "4.7.4",
     "webpack": "^5.73.0",
     "webpack-cli": "^4.10.0",
     "webpack-merge": "^5.8.0"

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

@@ -1,13 +1,17 @@
+import { undefined } from 'spica/global';
 import { Parser } from '../../data/parser';
 
 export function convert<P extends Parser<unknown>>(conv: (source: string) => string, parser: P): P;
 export function convert<T>(conv: (source: string) => string, parser: Parser<T>): Parser<T> {
   assert(parser);
-  return (source, context) => {
+  return (source, context = {}) => {
     if (source === '') return;
     source = conv(source);
-    return source === ''
-      ? [[], '']
-      : parser(source, context);
+    if (source === '') return [[], ''];
+    const memo = context.memo;
+    context.memo = undefined;
+    const result = parser(source, context);
+    context.memo = memo;
+    return result;
   };
 }

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

@@ -8,13 +8,16 @@ export function focus<T>(scope: string | RegExp, parser: Parser<T>): Parser<T> {
   const match: (source: string) => string = typeof scope === 'string'
     ? source => source.slice(0, scope.length) === scope ? scope : ''
     : source => source.match(scope)?.[0] ?? '';
-  return (source, context) => {
+  return (source, context = {}) => {
     if (source === '') return;
     const src = match(source);
     assert(source.startsWith(src));
     if (src === '') return;
+    const memo = context.memo;
+    memo && (memo.offset = source.length - src.length);
     const result = parser(src, context);
     assert(check(src, result));
+    memo && (memo.offset = source.length + src.length);
     if (!result) return;
     assert(exec(result).length < src.length);
     return exec(result).length < src.length
@@ -28,16 +31,21 @@ export function rewrite<P extends Parser<unknown>>(scope: Parser<unknown, Contex
 export function rewrite<T>(scope: Parser<unknown>, parser: Parser<T>): Parser<T> {
   assert(scope);
   assert(parser);
-  return (source, context) => {
+  return (source, context = {}) => {
     if (source === '') return;
+    const memo = context.memo;
+    context.memo = undefined;
     const res1 = scope(source, context);
     assert(check(source, res1));
+    context.memo = memo;
     if (!res1 || exec(res1).length >= source.length) return;
     const src = source.slice(0, source.length - exec(res1).length);
     assert(src !== '');
     assert(source.startsWith(src));
+    memo && (memo.offset = source.length - src.length);
     const res2 = parser(src, context);
     assert(check(src, res2));
+    memo && (memo.offset = source.length + src.length);
     if (!res2) return;
     assert(exec(res2) === '');
     return exec(res2).length < src.length

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

@@ -0,0 +1,70 @@
+import { memoize, reduce } from 'spica/memoize';
+
+export class Delimiters {
+  public static signature(pattern: string | RegExp | undefined): string {
+    switch (typeof pattern) {
+      case 'undefined':
+        return `undefined`;
+      case 'string':
+        return `s:${pattern}`;
+      case 'object':
+        return `r/${pattern.source}/${pattern.flags}`;
+    }
+  }
+  public static matcher = memoize(
+    (pattern: string | RegExp | undefined): (source: string) => true | undefined => {
+      switch (typeof pattern) {
+        case 'undefined':
+          return () => undefined;
+        case 'string':
+          return source => source.slice(0, pattern.length) === pattern || undefined;
+        case 'object':
+          return reduce(source => pattern.test(source) || undefined);
+      }
+    },
+    this.signature);
+  private readonly matchers: [number, string, number, (source: string) => boolean | undefined][] = [];
+  private readonly registry: Record<string, boolean> = {};
+  private length = 0;
+  public push(
+    ...delimiters: readonly {
+      readonly signature: string;
+      readonly matcher: (source: string) => boolean | undefined;
+      readonly precedence?: number;
+    }[]
+  ): void {
+    for (let i = 0; i < delimiters.length; ++i) {
+      const delimiter = delimiters[i];
+      assert(this.length >= this.matchers.length);
+      const { signature, matcher, precedence = 1 } = delimiter;
+      if (!this.registry[signature]) {
+        this.matchers.unshift([this.length, signature, precedence, matcher]);
+        this.registry[signature] = true;
+      }
+      ++this.length;
+    }
+  }
+  public pop(count = 1): void {
+    assert(count > 0);
+    for (let i = 0; i < count; ++i) {
+      assert(this.matchers.length > 0);
+      assert(this.length >= this.matchers.length);
+      if (--this.length === this.matchers[0][0]) {
+        this.registry[this.matchers.shift()![1]] = false;
+      }
+    }
+  }
+  public match(source: string, precedence = 1): boolean {
+    const { matchers } = this;
+    for (let i = 0; i < matchers.length; ++i) {
+      switch (matchers[i][3](source)) {
+        case true:
+          if (precedence < matchers[i][2]) return true;
+          continue;
+        case false:
+          return false;
+      }
+    }
+    return false;
+  }
+}

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

@@ -0,0 +1,34 @@
+export class Memo {
+  private memory: Record<string, readonly [any[], number]>[/* pos */] = [];
+  public get length(): number {
+    return this.memory.length;
+  }
+  public offset = 0;
+  public get(
+    position: number,
+    syntax: number,
+    state: number,
+  ): readonly [any[], number] | undefined {
+    //console.log('get', position + this.offset, syntax, state, this.memory[position + this.offset - 1]?.[`${syntax}:${state}`]);;
+    return this.memory[position + this.offset - 1]?.[`${syntax}:${state}`];
+  }
+  public set(
+    position: number,
+    syntax: number,
+    state: number,
+    nodes: any[],
+    offset: number,
+  ): void {
+    const record = this.memory[position + this.offset - 1] ??= {};
+    assert(!record[`${syntax}:${state}`]);
+    record[`${syntax}:${state}`] = [nodes.slice(), offset];
+    //console.log('set', position + this.offset, syntax, state);
+  }
+  public clear(position: number): void {
+    const memory = this.memory;
+    for (let i = position + this.offset, len = memory.length; i < len; ++i) {
+      memory.pop();
+    }
+    //console.log(position);
+  }
+}

package/src/combinator/{control/manipulation → data/parser}/context.test.ts

@@ -1,11 +1,11 @@
-import { Parser, Ctx } from '../../data/parser';
-import { some } from '../../data/parser/some';
+import { Parser, Ctx } from '../parser';
+import { some } from './some';
 import { reset, context } from './context';
-import { creator } from './resource';
+import { creator } from './context';
 
-describe('Unit: combinator/context', () => {
+describe('Unit: combinator/data/parser/context', () => {
   interface Context extends Ctx {
-    state?: boolean;
+    status?: boolean;
   }
 
   describe('reset', () => {
@@ -37,17 +37,17 @@ describe('Unit: combinator/context', () => {
 
   describe('context', () => {
     const parser: Parser<boolean, Context> = some(creator(
-      (s, context) => [[context.state!], s.slice(1)]));
+      (s, context) => [[context.status!], s.slice(1)]));
 
     it('', () => {
-      const base: Context = { state: true };
+      const base: Context = { status: true };
       const ctx: Context = { resources: { budget: 3, recursion: 1 } };
       assert.deepStrictEqual(context(base, parser)('123', ctx), [[true, true, true], '']);
       assert(ctx.resources?.budget === 0);
-      assert(ctx.state === undefined);
+      assert(ctx.status === undefined);
       assert.throws(() => reset(base, parser)('1', ctx));
       assert(ctx.resources?.budget === 0);
-      assert(ctx.state === undefined);
+      assert(ctx.status === undefined);
     });
 
   });

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

@@ -0,0 +1,158 @@
+import { undefined, Array, Object } from 'spica/global';
+import { hasOwnProperty, ObjectCreate } from 'spica/alias';
+import { Parser, Result, Ctx, Context, eval, exec, Tree } from '../../data/parser';
+import { Memo } from './context/memo';
+
+export function reset<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
+export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
+  assert(Object.getPrototypeOf(base) === Object.prototype);
+  assert(Object.freeze(base));
+  const changes = Object.entries(base);
+  const values = Array(changes.length);
+  return (source, context) =>
+    apply(parser, source, ObjectCreate(context), changes, values);
+}
+
+export function context<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
+export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
+  assert(Object.getPrototypeOf(base) === Object.prototype);
+  assert(Object.freeze(base));
+  const changes = Object.entries(base);
+  const values = Array(changes.length);
+  return (source, context) =>
+    apply(parser, source, context, changes, values);
+}
+
+function apply<P extends Parser<unknown>>(parser: P, source: string, context: Context<P>, changes: [string, any][], values: any[]): Result<Tree<P>>;
+function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: [string, any][], values: any[]): Result<T> {
+  if (context) for (let i = 0; i < changes.length; ++i) {
+    const change = changes[i];
+    const prop = change[0];
+    switch (prop) {
+      case 'resources':
+        assert(typeof change[1] === 'object');
+        assert(context[prop] || !(prop in context));
+        if (prop in context && !hasOwnProperty(context, prop)) break;
+        // @ts-expect-error
+        context[prop] = ObjectCreate(change[1]);
+        break;
+      default:
+        values[i] = context[prop];
+        context[prop] = change[1];
+    }
+  }
+  const result = parser(source, context);
+  if (context) for (let i = 0; i < changes.length; ++i) {
+    const change = changes[i];
+    const prop = change[0];
+    switch (prop) {
+      case 'resources':
+        break;
+      default:
+        context[prop] = values[i];
+        values[i] = undefined;
+    }
+  }
+  return result;
+}
+
+export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, parser: P): P;
+export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, cost: number, parser: P): P;
+export function syntax<T>(syntax: number, precedence: number, cost: number | Parser<T>, parser?: Parser<T>): Parser<T> {
+  if (typeof cost === 'function') {
+    parser = cost;
+    cost = 1;
+  }
+  return (source, context) => {
+    if (source === '') return;
+    context.backtrackable ??= ~0;
+    const state = context.state ??= 0;
+    const p = context.precedence;
+    context.precedence = precedence;
+    const { resources = { budget: 1, recursion: 1 } } = context;
+    if (resources.budget <= 0) throw new Error('Too many creations');
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
+    --resources.recursion;
+    const pos = source.length;
+    const cache = syntax && context.memo?.get(pos, syntax, state);
+    const result: Result<T> = cache
+      ? [cache[0], source.slice(cache[1])]
+      : parser!(source, context);
+    ++resources.recursion;
+    if (result) {
+      if (!cache) {
+        assert(cost = cost as number);
+        resources.budget -= cost;
+      }
+      if (syntax) {
+        if (state & context.backtrackable) {
+          context.memo ??= new Memo();
+          cache ?? context.memo.set(pos, syntax, state, eval(result), source.length - exec(result).length);
+          assert.deepStrictEqual(cache && cache, cache && context.memo.get(pos, syntax, state));
+        }
+        else if (context.memo?.length! >= pos) {
+          assert(!(state & context.backtrackable));
+          context.memo!.clear(pos);
+        }
+      }
+    }
+    context.precedence = p;
+    return result;
+  };
+}
+
+export function creator<P extends Parser<unknown>>(parser: P): P;
+export function creator<P extends Parser<unknown>>(cost: number, parser: P): P;
+export function creator(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
+  if (typeof cost === 'function') return creator(1, cost);
+  assert(cost >= 0);
+  return (source, context) => {
+    const { resources = { budget: 1, recursion: 1 } } = context;
+    if (resources.budget <= 0) throw new Error('Too many creations');
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
+    --resources.recursion;
+    const result = parser!(source, context);
+    ++resources.recursion;
+    if (result) {
+      resources.budget -= cost;
+    }
+    return result;
+  };
+}
+
+export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
+export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
+  return (source, context) => {
+    const p = context.precedence;
+    context.precedence = precedence;
+    const result = parser(source, context);
+    context.precedence = p;
+    return result;
+  };
+}
+
+export function guard<P extends Parser<unknown>>(f: (context: Context<P>) => boolean | number, parser: P): P;
+export function guard<T>(f: (context: Ctx) => boolean | number, parser: Parser<T>): Parser<T> {
+  return (source, context) =>
+    f(context)
+      ? parser(source, context)
+      : undefined;
+}
+
+export function state<P extends Parser<unknown>>(state: number, parser: P): P;
+export function state<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
+export function state<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
+  if (typeof positive === 'function') {
+    parser = positive;
+    positive = true;
+  }
+  return (source, context) => {
+    const s = context.state ?? 0;
+    context.state = positive
+      ? s | state
+      : s & ~state;
+    const result = parser!(source, context);
+    context.state = s;
+    return result;
+  };
+}

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

@@ -2,8 +2,8 @@ import { undefined } from 'spica/global';
 import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function inits<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function inits<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return (source, context) => {
@@ -11,14 +11,15 @@ export function inits<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
     let nodes: T[] | undefined;
     for (let i = 0, len = parsers.length; i < len; ++i) {
       if (rest === '') break;
+      if (context.delimiters?.match(rest, context.precedence)) break;
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) break;
-      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);
       rest = exec(result);
+      if (resume?.(eval(result), exec(result)) === false) break;
     }
     assert(rest.length <= source.length);
     return nodes && rest.length < source.length

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

@@ -2,7 +2,7 @@ import { Parser } from '../parser';
 import { sequence } from './sequence';
 import { inspect } from '../../../debug.test';
 
-describe('Unit: combinator/sequence', () => {
+describe('Unit: combinator/data/parser/sequence', () => {
   describe('sequence', () => {
     const a: Parser<string, never> = source => {
       return source && source[0] === 'a'

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

@@ -2,8 +2,8 @@ import { undefined } from 'spica/global';
 import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function sequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function sequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return (source, context) => {
@@ -11,14 +11,15 @@ export function sequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D
     let nodes: T[] | undefined;
     for (let i = 0, len = parsers.length; i < len; ++i) {
       if (rest === '') return;
+      if (context.delimiters?.match(rest, context.precedence)) return;
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) return;
-      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);
       rest = exec(result);
+      if (resume?.(eval(result), exec(result)) === false) return;
     }
     assert(rest.length <= source.length);
     return nodes && rest.length < source.length

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

@@ -3,7 +3,7 @@ import { union } from './union';
 import { some } from './some';
 import { inspect } from '../../../debug.test';
 
-describe('Unit: combinator/some', () => {
+describe('Unit: combinator/data/parser/some', () => {
   describe('some', () => {
     const a: Parser<string, never> = source => {
       return source && source[0] === 'a'

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

@@ -1,51 +1,28 @@
 import { undefined } from 'spica/global';
-import { Parser, Delimiters, eval, exec, check } from '../parser';
-import { memoize, reduce } from 'spica/memoize';
+import { Parser, eval, exec, check } from '../parser';
+import { Delimiters } from './context/delimiter';
 import { push } from 'spica/array';
 
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
-const signature = (pattern: string | RegExp | undefined): string => {
-  switch (typeof pattern) {
-    case 'undefined':
-      return signature('');
-    case 'string':
-      return `s:${pattern}`;
-    case 'object':
-      return `r/${pattern.source}/${pattern.flags}`;
-  }
-};
-const matcher = memoize(
-  (pattern: string | RegExp | undefined): (source: string) => true | undefined => {
-    switch (typeof pattern) {
-      case 'undefined':
-        return () => undefined;
-      case 'string':
-        return source => source.slice(0, pattern.length) === pattern || undefined;
-      case 'object':
-        return reduce(source => pattern.test(source) || undefined);
-    }
-  },
-  signature);
-
-export function some<P extends Parser<unknown>>(parser: P, until?: string | RegExp | number, deeps?: readonly DelimiterOption[], limit?: number): P;
-export function some<T>(parser: Parser<T>, until?: string | RegExp | number, deeps: readonly DelimiterOption[] = [], limit = -1): Parser<T> {
-  if (typeof until === 'number') return some(parser, undefined, deeps, until);
+export function some<P extends Parser<unknown>>(parser: P, end?: string | RegExp | number, delimiters?: readonly DelimiterOption[], limit?: number): P;
+export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delimiters: readonly DelimiterOption[] = [], limit = -1): Parser<T> {
+  if (typeof end === 'number') return some(parser, undefined, delimiters, end);
   assert(parser);
-  assert([until].concat(deeps.map(o => o[0])).every(d => d instanceof RegExp ? !d.flags.match(/[gmy]/) && d.source.startsWith('^') : true));
-  const match = matcher(until);
-  const delimiters = deeps.map(([delimiter, precedence]) => ({
-    signature: signature(delimiter),
-    matcher: matcher(delimiter),
+  assert([end].concat(delimiters.map(o => o[0])).every(d => d instanceof RegExp ? !d.flags.match(/[gmy]/) && d.source.startsWith('^') : true));
+  const match = Delimiters.matcher(end);
+  const delims = delimiters.map(([delimiter, precedence]) => ({
+    signature: Delimiters.signature(delimiter),
+    matcher: Delimiters.matcher(delimiter),
     precedence,
   }));
   return (source, context) => {
     if (source === '') return;
     let rest = source;
     let nodes: T[] | undefined;
-    if (delimiters.length > 0) {
+    if (delims.length > 0) {
       context.delimiters ??= new Delimiters();
-      context.delimiters.push(...delimiters);
+      context.delimiters.push(...delims);
     }
     while (true) {
       if (rest === '') break;
@@ -60,8 +37,8 @@ export function some<T>(parser: Parser<T>, until?: string | RegExp | number, dee
       rest = exec(result);
       if (limit >= 0 && source.length - rest.length > limit) break;
     }
-    if (delimiters.length > 0) {
-      context.delimiters!.pop(delimiters.length);
+    if (delims.length > 0) {
+      context.delimiters!.pop(delims.length);
     }
     assert(rest.length <= source.length);
     return nodes && rest.length < source.length

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

@@ -2,7 +2,7 @@ import { Parser } from '../parser';
 import { subsequence } from './subsequence';
 import { inspect } from '../../../debug.test';
 
-describe('Unit: combinator/subsequence', () => {
+describe('Unit: combinator/data/parser/subsequence', () => {
   describe('subsequence', () => {
     const a: Parser<string, never> = source => {
       return source && source[0] === 'a'

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

@@ -2,12 +2,12 @@ import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
-export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function subsequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function subsequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>
       i + 1 < parsers.length
-        ? inits([parsers[i], subsequence(parsers.slice(i + 1))])
+        ? inits([parsers[i], subsequence(parsers.slice(i + 1), resume)], resume)
         : parsers[i]) as D);
 }

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

@@ -2,7 +2,7 @@ import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
-export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function tails<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
-  return union(parsers.map((_, i) => sequence(parsers.slice(i))) as D);
+export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function tails<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+  return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

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

@@ -2,7 +2,7 @@ import { Parser } from '../parser';
 import { union } from './union';
 import { inspect } from '../../../debug.test';
 
-describe('Unit: combinator/union', () => {
+describe('Unit: combinator/data/parser/union', () => {
   describe('union', () => {
     const a: Parser<string, never> = source => {
       return source && source[0] === 'a'