securemark 0.294.0 → 0.294.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.294.0",
+  "version": "0.294.2",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -28,7 +28,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "spica": "0.0.807"
+    "spica": "0.0.809"
   },
   "devDependencies": {
     "@types/dompurify": "3.0.5",

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

@@ -1,4 +1,4 @@
-import { Parser, Input, List, Data, Ctx, Node, Context, eval, failsafe } from '../../data/parser';
+import { Parser, Input, List, Data, Ctx, Node, Context, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
 //export function contract<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
@@ -37,7 +37,7 @@ export function verify<N>(parser: Parser<N>, cond: (nodes: List<Data<N>>, contex
     if (position === source.length) return;
     const result = parser(input);
     assert(context.position > position || !result);
-    if (result && !cond(eval(result), context)) return;
+    if (result && !cond(result, context)) return;
     return result;
   });
 }

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

@@ -1,4 +1,4 @@
-import { Parser, input, eval, failsafe } from '../../data/parser';
+import { Parser, input, failsafe } from '../../data/parser';
 
 export function line<P extends Parser<unknown>>(parser: P): P;
 export function line<N>(parser: Parser<N>): Parser<N> {
@@ -18,7 +18,7 @@ export function line<N>(parser: Parser<N>): Parser<N> {
     if (result === undefined) return;
     if (!isBlank(source.slice(context.position, position + line.length))) return;
     context.position = position + line.length;
-    return eval(result);
+    return result;
   });
 }
 

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

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

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, subinput, eval, failsafe } from '../../data/parser';
+import { Parser, List, Data, subinput, failsafe } from '../../data/parser';
 import { some } from '../../data/parser/some';
 import { block } from '../constraint/block';
 import { line } from '../constraint/line';
@@ -26,14 +26,10 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
         context.position = source.length;
         return new List([new Data(source.slice(position))]);
       }))),
-    ([indent]) => indent.length * 2 + +(indent[0] === ' '), {})), separation),
+    ([indent]) => indent.length <= 16 ? indent.length * 2 + +(indent[0] === ' ') : -1, [])), separation),
     (lines, context) => {
       assert(parser = parser as Parser<N>);
-      const result = parser(subinput(trimBlockEnd(lines.foldl((acc, node) => acc + node.value, '')), context));
-      assert(result);
-      return result
-        ? eval(result)
-        : undefined;
+      return parser(subinput(trimBlockEnd(lines.foldl((acc, node) => acc + node.value, '')), context));
     }));
 }
 

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

@@ -4,7 +4,5 @@ export function lazy<P extends Parser<unknown>>(builder: () => P): P;
 export function lazy<N>(builder: () => Parser<N>): Parser<N> {
   let parser: Parser<N>;
   return input =>
-    parser !== undefined
-      ? parser(input)
-      : (parser = builder())(input);
+    (parser ??= builder())(input);
 }

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

@@ -1,4 +1,4 @@
-import { Parser, Context, input, eval, failsafe } from '../../data/parser';
+import { Parser, Context, input, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
 export function focus<P extends Parser<unknown>>(scope: string | RegExp, parser: P): P;
@@ -8,7 +8,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>): Parser<N> {
   return failsafe(({ context }) => {
     const { source, position } = context;
     if (position === source.length) return;
-    const src = eval(match({ context }))?.head?.value ?? '';
+    const src = match({ context })?.head?.value ?? '';
     assert(source.startsWith(src, position));
     if (src === '') return;
     context.range = src.length;
@@ -20,8 +20,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>): Parser<N> {
     assert(context.position > position || !result);
     context.source = source;
     context.offset -= position;
-    if (result === undefined) return;
-    return eval(result);
+    return result;
   });
 }
 
@@ -47,7 +46,6 @@ export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>): Parser<N>
     assert(context.position > position || !res2);
     context.source = source;
     context.offset -= position;
-    if (res2 === undefined) return;
-    return eval(res2);
+    return res2;
   });
 }

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

@@ -1,4 +1,4 @@
-import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
+import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, failsafe } from '../../data/parser';
 import { matcher, clear } from '../../../combinator';
 
 export function surround<P extends Parser<unknown>, S = string>(
@@ -52,29 +52,26 @@ export function surround<N>(
     if (position === source.length) return;
     const { linebreak } = context;
     context.linebreak = 0;
-    const resultO = opener(input);
+    const nodesO = opener(input);
     assert(context.position >= position);
-    const nodesO = eval(resultO);
     if (!nodesO) {
       return void revert(context, linebreak);
     }
     if (isBacktrack(context, backtracks, position, context.position - position || 1)) {
       return void revert(context, linebreak);
     }
-    const resultM = context.position < source.length ? parser(input) : undefined;
+    const nodesM = context.position < source.length ? parser(input) : undefined;
     assert(context.position >= position);
     context.range = context.position - position;
-    const nodesM = eval(resultM);
-    if (!resultM && !optional) {
+    if (!nodesM && !optional) {
       setBacktrack(context, backtracks, position);
       const result = g?.([nodesO, nodesM], context);
       revert(context, linebreak);
       return result;
     }
-    const resultC = resultM || optional ? closer(input) : undefined;
+    const nodesC = nodesM || optional ? closer(input) : undefined;
     assert(context.position >= position);
     context.range = context.position - position;
-    const nodesC = eval(resultC);
     if (!nodesC) {
       setBacktrack(context, backtracks, position);
       const result = g?.([nodesO, nodesM], context);

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

@@ -1,4 +1,4 @@
-import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
+import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, failsafe } from '../../data/parser';
 
 export function bind<P extends Parser<unknown>>(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<unknown>>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
@@ -14,9 +14,8 @@ export function bind<N, U>(parser: Parser<N>, f: (nodes: List<Data<N>>, context:
     assert(context.position > position || !res1);
     if (res1 === undefined) return;
     context.range = context.position - position;
-    const res2 = f(eval(res1), context);
+    const res2 = f(res1, context);
     assert(context.position > position || !res2);
-    if (res2 === undefined) return;
     return context.position > position
       ? res2
       : undefined;

package/src/combinator/data/data.ts

@@ -1,6 +1,6 @@
-// Memory-efficient flexible list.
+import { Parser, Ctx } from './parser';
 
-export class List<N extends List.Node = List.Node> {
+export class List<N extends List.Node = List.Node, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any> {
   constructor(nodes?: ArrayLike<N>) {
     if (nodes === undefined) return;
     for (let i = 0; i < nodes.length; ++i) {
@@ -9,47 +9,55 @@ export class List<N extends List.Node = List.Node> {
   }
   public length = 0;
   public head?: N = undefined;
+  public last?: N = undefined;
   public get tail(): N | undefined {
     return this.head?.next;
   }
-  public get last(): N | undefined {
-    return this.head?.prev;
-  }
   public insert(node: N, before?: N): N {
-    assert(!node.next);
+    assert(!node.next && !node.prev);
+    if (before === undefined) return this.push(node);
+    if (before === this.head) return this.unshift(node);
     if (++this.length === 1) {
-      return this.head = node.next = node.prev = node;
+      return this.head = this.last = node;
     }
     assert(node !== before);
-    const next = node.next = before ?? this.head!;
+    const next = node.next = before;
     const prev = node.prev = next.prev!;
     return next.prev = prev.next = node;
   }
   public delete(node: N): N {
-    assert(node.next);
+    assert(node.next || node.prev || this.head === this.last);
     assert(this.length > 0);
     if (--this.length === 0) {
-      this.head = undefined;
+      this.head = this.last = undefined;
     }
     else {
       const { next, prev } = node;
-      if (node === this.head) {
-        this.head = next;
-      }
-      // Error if not used.
-      prev!.next = next;
-      next!.prev = prev;
+      prev === undefined
+        ? this.head = next
+        : prev.next = next;
+      next === undefined
+        ? this.last = prev
+        : next.prev = prev;
     }
     node.next = node.prev = undefined;
     return node;
   }
   public unshift(node: N): N {
-    assert(!node.next);
-    return this.head = this.insert(node, this.head);
+    assert(!node.next && !node.prev);
+    if (++this.length === 1) {
+      return this.head = this.last = node;
+    }
+    node.next = this.head;
+    return this.head = this.head!.prev = node;
   }
   public push(node: N): N {
-    assert(!node.next);
-    return this.insert(node, this.head);
+    assert(!node.next && !node.prev);
+    if (++this.length === 1) {
+      return this.head = this.last = node;
+    }
+    node.prev = this.last;
+    return this.last = this.last!.next = node;
   }
   public shift(): N | undefined {
     if (this.length === 0) return;
@@ -57,22 +65,25 @@ export class List<N extends List.Node = List.Node> {
   }
   public pop(): N | undefined {
     if (this.length === 0) return;
-    return this.delete(this.head!.prev!);
+    return this.delete(this.last!);
   }
   public import(list: List<N>, before?: N): this {
     assert(list !== this);
     if (list.length === 0) return this;
     if (this.length === 0) {
       this.head = list.head;
-      this.length += list.length;
+      this.last = list.last;
+      this.length = list.length;
       list.clear();
       return this;
     }
     const head = list.head!;
     const last = list.last!;
-    const next = last.next = before ?? this.head!;
-    const prev = head.prev = next.prev!;
-    next.prev = last;
+    const next = last.next = before;
+    const prev = head.prev = before?.prev ?? this.last!;
+    next === undefined
+      ? this.last = last
+      : next.prev = last;
     prev.next = head;
     this.length += list.length;
     list.clear();
@@ -80,14 +91,13 @@ export class List<N extends List.Node = List.Node> {
   }
   public clear(): void {
     this.length = 0;
-    this.head = undefined;
+    this.head = this.last = undefined;
   }
   public *[Symbol.iterator](): Iterator<N, undefined, undefined> {
     for (let node = this.head; node && this.head;) {
       const next = node.next;
       yield node;
       node = next;
-      if (node === this.head) break;
     }
   }
   public flatMap<T extends List.Node>(f: (node: N) => List<T>): List<T> {
@@ -96,7 +106,6 @@ export class List<N extends List.Node = List.Node> {
       const next = node.next;
       acc.import(f(node));
       node = next;
-      if (node === this.head) break;
     }
     return acc;
   }
@@ -105,15 +114,13 @@ export class List<N extends List.Node = List.Node> {
       const next = node.next;
       acc = f(acc, node);
       node = next;
-      if (node === this.head) break;
     }
     return acc;
   }
   public foldr<T>(f: (node: N, acc: T) => T, acc: T): T {
-    for (let node = this.head?.prev; node && this.head;) {
+    for (let node = this.last; node && this.head;) {
       const prev = node.prev;
       acc = f(node, acc);
-      if (node === this.head) break;
       node = prev;
     }
     return acc;
@@ -123,7 +130,6 @@ export class List<N extends List.Node = List.Node> {
       const next = node.next;
       if (f(node)) return node;
       node = next;
-      if (node === this.head) break;
     }
   }
 }

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, CtxOptions, input, eval } from '../parser';
+import { Parser, List, Data, Ctx, CtxOptions, input } from '../parser';
 import { some } from './some';
 import { reset, context, creation } from './context';
 import { unwrap } from '../../../parser/util';
@@ -18,7 +18,7 @@ describe('Unit: combinator/data/parser/context', () => {
     it('root', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = {};
-      assert.deepStrictEqual([...unwrap(eval(reset(base, parser)(input('123', ctx)))!)], [3, 2, 1]);
+      assert.deepStrictEqual([...unwrap(reset(base, parser)(input('123', ctx))!)], [3, 2, 1]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === undefined);
       assert.throws(() => reset(base, parser)(input('1234', ctx)));
@@ -28,7 +28,7 @@ describe('Unit: combinator/data/parser/context', () => {
     it('node', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = { resources: { clock: 2, recursions: [1] } };
-      assert.deepStrictEqual([...unwrap(eval(reset(base, parser)(input('1', ctx)))!)], [2]);
+      assert.deepStrictEqual([...unwrap(reset(base, parser)(input('1', ctx))!)], [2]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === 1);
       assert.throws(() => reset(base, parser)(input('12', ctx)));
@@ -47,7 +47,7 @@ describe('Unit: combinator/data/parser/context', () => {
     it('', () => {
       const base: Context = { status: true };
       const ctx: Context = { resources: { clock: 2, recursions: [1] } };
-      assert.deepStrictEqual([...unwrap(eval(context(base, parser)(input('1', ctx)))!)], [true]);
+      assert.deepStrictEqual([...unwrap(context(base, parser)(input('1', ctx))!)], [true]);
       assert(base.resources?.clock === undefined);
       assert(ctx.resources?.clock === 1);
       assert(ctx.status === undefined);

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

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

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { sequence } from './sequence';
 import { inspect } from '../../../debug.test';
 
@@ -14,7 +14,7 @@ describe('Unit: combinator/data/parser/sequence', () => {
         ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
-    const ab = sequence<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const ab = sequence<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

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

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

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { union } from './union';
 import { some } from './some';
 import { inspect } from '../../../debug.test';
@@ -15,7 +15,7 @@ describe('Unit: combinator/data/parser/some', () => {
         ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
-    const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const ab = union<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, eval } from '../parser';
+import { Parser, List, Data } from '../parser';
 import { Delimiters } from './context/delimiter';
 
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
@@ -23,22 +23,20 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
       context.delimiters ??= new Delimiters();
       context.delimiters.push(delims);
     }
-    while (true) {
-      if (context.position === source.length) break;
+    // whileは数倍遅い
+    for (; context.position < source.length;) {
       if (match(input)) break;
       if (context.delimiters?.match(input)) break;
       const result = parser(input);
       if (result === undefined) break;
-      nodes = nodes
-        ? nodes.import(eval(result))
-        : eval(result);
+      nodes = nodes?.import(result) ?? result;
       if (limit >= 0 && context.position - position > limit) break;
     }
     if (delims.length > 0) {
       context.delimiters!.pop(delims.length);
     }
     assert(context.position >= position);
-    return nodes && context.position > position
+    return context.position > position
       ? nodes
       : undefined;
   };

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { subsequence } from './subsequence';
 import { inspect } from '../../../debug.test';
 
@@ -19,7 +19,7 @@ describe('Unit: combinator/data/parser/subsequence', () => {
         ? void ++context.position || new List([new Data('C')])
         : undefined;
     };
-    const abc = subsequence<Parser<string, {}, [typeof a, typeof b, typeof c]>>([a, b, c]);
+    const abc = subsequence<Parser<string, Ctx, [typeof a, typeof b, typeof c]>>([a, b, c]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

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

@@ -1,9 +1,9 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
 export function subsequence<P extends Parser<unknown>>(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 subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
+export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>

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

@@ -1,8 +1,8 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
 export function tails<P extends Parser<unknown>>(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 tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
+export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
   return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { union } from './union';
 import { inspect } from '../../../debug.test';
 
@@ -14,7 +14,7 @@ describe('Unit: combinator/data/parser/union', () => {
         ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
-    const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const ab = union<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

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

@@ -1,7 +1,7 @@
-import { Parser, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 
 export function union<P extends Parser<unknown>>(parsers: SubParsers<P>): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, CtxOptions, D> {
+export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0: