securemark 0.294.10 → 0.295.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.294.10",
+  "version": "0.295.0",
   "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.ts

@@ -1,7 +1,7 @@
 import { Parser, failsafe } from '../../data/parser';
 import { isBlankline } from './line';
 
-export function block<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
+export function block<P extends Parser>(parser: P, separation?: boolean): P;
 export function block<N>(parser: Parser<N>, separation = true): Parser<N> {
   assert(parser);
   return failsafe(input => {

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

@@ -1,13 +1,13 @@
 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;
+//export function contract<P extends Parser>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
 //export function contract<N>(patterns: string | RegExp | (string | RegExp)[], parser: Parser<N>, cond: (nodes: readonly N[], rest: string) => boolean): Parser<N> {
 //  return verify(validate(patterns, parser), cond);
 //}
 
-export function validate<P extends Parser<unknown>>(pattern: string | RegExp, parser: P): P;
-export function validate<P extends Parser<unknown>>(cond: ((input: Input<Context<P>>) => boolean), parser: P): P;
+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> {
   if (typeof pattern === 'function') return guard(pattern, parser);
   const match = matcher(pattern, false);
@@ -20,7 +20,7 @@ export function validate<N>(pattern: string | RegExp | ((input: Input<Ctx>) => b
   };
 }
 
-function guard<P extends Parser<unknown>>(f: (input: Input<Context<P>>) => boolean, parser: P): P;
+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> {
   return input =>
     f(input)
@@ -28,7 +28,7 @@ function guard<N>(f: (input: Input<Ctx>) => boolean, parser: Parser<N>): Parser<
       : undefined;
 }
 
-export function verify<P extends Parser<unknown>>(parser: P, cond: (nodes: List<Data<Node<P>>>, context: Context<P>) => boolean): P;
+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> {
   assert(parser);
   return failsafe(input => {
@@ -36,7 +36,6 @@ export function verify<N>(parser: Parser<N>, cond: (nodes: List<Data<N>>, contex
     const { source, position } = context;
     if (position === source.length) return;
     const result = parser(input);
-    assert(context.position > position || !result);
     if (result && !cond(result, context)) return;
     return result;
   });

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

@@ -1,6 +1,6 @@
 import { Parser, input, failsafe } from '../../data/parser';
 
-export function line<P extends Parser<unknown>>(parser: P): P;
+export function line<P extends Parser>(parser: P): P;
 export function line<N>(parser: Parser<N>): Parser<N> {
   assert(parser);
   return failsafe(({ context }) => {
@@ -12,7 +12,6 @@ export function line<N>(parser: Parser<N>): Parser<N> {
     const result = parser(input(line, context));
     context.position += position;
     context.position += result && context.position === position ? line.length : 0;
-    assert(context.position > position || !result);
     context.source = source;
     context.offset -= position;
     if (result === undefined) return;

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

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

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

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

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

@@ -7,8 +7,8 @@ import { match } from './match';
 import { open } from './surround';
 import { memoize } from 'spica/memoize';
 
-export function indent<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
-export function indent<P extends Parser<unknown>>(opener: RegExp, parser: P, separation?: boolean): P;
+export function indent<P extends Parser>(parser: P, separation?: boolean): P;
+export function indent<P extends Parser>(opener: RegExp, parser: P, separation?: boolean): P;
 export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolean = false, separation = false): Parser<N> {
   if (typeof opener === 'function') {
     separation = parser as boolean;

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

@@ -1,6 +1,6 @@
 import { Parser } from '../../data/parser';
 
-export function lazy<P extends Parser<unknown>>(builder: () => P): P;
+export function lazy<P extends Parser>(builder: () => P): P;
 export function lazy<N>(builder: () => Parser<N>): Parser<N> {
   let parser: Parser<N>;
   return input =>

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

@@ -1,7 +1,7 @@
 import { Parser, failsafe } from '../../data/parser';
 import { consume } from '../../../combinator';
 
-export function match<P extends Parser<unknown>>(pattern: RegExp, f: (matched: RegExpMatchArray) => P): P;
+export function match<P extends Parser>(pattern: RegExp, f: (matched: RegExpMatchArray) => P): P;
 export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<N>): Parser<N> {
   assert(!pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^'));
   const count = typeof pattern === 'object'
@@ -18,9 +18,6 @@ export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Pars
     count && consume(params[0].length, context);
     const result = f(params)(input);
     context.position += result && context.position === position ? params[0].length : 0;
-    assert(context.position > position || !result);
-    return context.position > position
-      ? result
-      : undefined;
+    return result;
   });
 }

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

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

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

@@ -1,7 +1,7 @@
 import { Parser, List, Data } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 
-export function reverse<P extends Parser<unknown>>(parser: P): P;
+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>>()));
 }

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

@@ -1,7 +1,7 @@
 import { Parser, Context, input, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
-export function focus<P extends Parser<unknown>>(scope: string | RegExp, parser: P, slice?: boolean): P;
+export function focus<P extends Parser>(scope: string | RegExp, parser: P, slice?: boolean): P;
 export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true): Parser<N> {
   assert(parser);
   const match = matcher(scope, false);
@@ -16,7 +16,6 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true
     if (!slice) {
       const result = parser(arg);
       context.position += result && context.position === position ? range : 0;
-      assert(context.position > position || !result);
       return result;
     }
     context.offset ??= 0;
@@ -24,7 +23,6 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true
     const result = parser(input(src, context));
     context.position += position;
     context.position += result && context.position === position ? src.length : 0;
-    assert(context.position > position || !result);
     context.source = source;
     context.offset -= position;
     return result;
@@ -32,8 +30,8 @@ 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<unknown>>(scope: Parser<unknown, Context<P>>, parser: P, slice?: boolean): P;
-export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>, slice = true): Parser<N> {
+export function rewrite<P extends Parser>(scope: Parser<unknown, Context<P>>, parser: P, slice?: boolean): P;
+export function rewrite<N>(scope: Parser, parser: Parser<N>, slice = true): Parser<N> {
   assert(scope);
   assert(parser);
   return failsafe(arg => {
@@ -48,7 +46,6 @@ export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>, slice = tr
       context.position = position;
       const res2 = parser(arg);
       context.position += res2 && context.position === position ? range : 0;
-      assert(context.position > position || !res2);
       return res2;
     }
     const src = source.slice(position, context.position);
@@ -59,7 +56,6 @@ export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>, slice = tr
     const res2 = parser(input(src, context));
     context.position += position;
     context.position += res2 && context.position === position ? src.length : 0;
-    assert(context.position > position || !res2);
     context.source = source;
     context.offset -= position;
     return res2;

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

@@ -1,52 +1,52 @@
 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>(
+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>>,
   optional?: false,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
   f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
 ): P;
-export function surround<P extends Parser<unknown>, S = string>(
+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>>,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
   f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
 ): P;
-export function surround<P extends Parser<unknown>, S = string>(
+export function surround<P extends Parser, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: false,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
   f?: (rss: [List<Data<S>>, List<Data<Node<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
 ): P;
-export function surround<P extends Parser<unknown>, S = string>(
+export function surround<P extends Parser, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
   f?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
 ): 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>>,
   optional?: false,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
   f?: (rss: [List<Data<S>>, List<Data<Node<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
 ): 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>>,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
   f?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
 ): 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[] = [],
+  backtracks: readonly [] | readonly [number] | readonly [number, number] = [],
   f?: (rss: [List<Data<N>>, List<Data<N>>, List<Data<N>>], context: Ctx) => Result<N>,
   g?: (rss: [List<Data<N>>, List<Data<N>> | undefined], context: Ctx) => Result<N>,
 ): Parser<N> {
@@ -68,6 +68,7 @@ export function surround<N>(
       closer = clear(matcher(closer, true));
   }
   assert(closer);
+  const [rbs, wbs] = reduce(backtracks);
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
@@ -75,26 +76,23 @@ export function surround<N>(
     const { linebreak } = context;
     context.linebreak = 0;
     const nodesO = opener(input);
-    assert(context.position >= position);
     if (!nodesO) {
       return void revert(context, linebreak);
     }
-    if (isBacktrack(context, backtracks, position, context.position - position || 1)) {
+    if (rbs && isBacktrack(context, rbs, position, context.position - position || 1)) {
       return void revert(context, linebreak);
     }
     const nodesM = context.position < source.length ? parser(input) : undefined;
-    assert(context.position >= position);
     context.range = context.position - position;
     if (!nodesM && !optional) {
-      setBacktrack(context, backtracks, position);
+      wbs && setBacktrack(context, wbs, position);
       const result = g?.([nodesO, nodesM], context);
       return result || void revert(context, linebreak);
     }
     const nodesC = nodesM || optional ? closer(input) : undefined;
-    assert(context.position >= position);
     context.range = context.position - position;
     if (!nodesC) {
-      setBacktrack(context, backtracks, position);
+      wbs && setBacktrack(context, wbs, position);
       const result = g?.([nodesO, nodesM], context);
       return result || void revert(context, linebreak);
     }
@@ -111,108 +109,99 @@ export function surround<N>(
     return result || void revert(context, linebreak);
   });
 }
-export function open<P extends Parser<unknown>>(
+export function open<P extends Parser>(
   opener: string | RegExp | Parser<Node<P>, Context<P>>,
   parser: P,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
 ): P;
 export function open<P extends Parser<string>>(
   opener: string | RegExp | Parser<Node<P>, Context<P>>,
   parser: string | RegExp | P,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
 ): P;
 export function open<N>(
   opener: string | RegExp | Parser<N, Ctx>,
   parser: string | RegExp | Parser<N>,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
 ): Parser<N> {
   return surround(opener, parser as Parser<N>, '', optional, backtracks);
 }
-export function close<P extends Parser<unknown>>(
+export function close<P extends Parser>(
   parser: P,
   closer: string | RegExp | Parser<Node<P>, Context<P>>,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
 ): P;
 export function close<P extends Parser<string>>(
   parser: string | RegExp | P,
   closer: string | RegExp | Parser<Node<P>, Context<P>>,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
 ): P;
 export function close<N>(
   parser: string | RegExp | Parser<N>,
   closer: string | RegExp | Parser<N, Ctx>,
   optional?: boolean,
-  backtracks?: readonly number[],
+  backtracks?: readonly [] | readonly [number] | readonly [number, number],
 ): Parser<N> {
   return surround('', parser as Parser<N>, closer, optional, backtracks);
 }
 
-const statesize = 2;
+const commandsize = 2;
 export function isBacktrack(
   context: Ctx,
-  backtracks: readonly number[],
+  backtrack: number,
   position: number = context.position,
   length: number = 1,
 ): boolean {
+  assert(backtrack & 1);
+  if (length === 0) return false;
   const { source } = context;
   if (position === source.length) return false;
-  if (length === 0) return false;
-  for (const backtrack of backtracks) {
-    if (backtrack & 1) {
-      const { backtracks = {}, offset = 0 } = context;
-      for (let i = 0; i < length; ++i) {
-        if (position + i === source.length) break;
-        if (source[position + i] !== source[position + 0]) break;
-        const pos = position + i + offset;
-        if (!(pos in backtracks)) continue;
-        if (backtracks[pos] & 1 << size(backtrack >>> statesize)) return true;
-      }
-    }
+  const { backtracks = {}, offset = 0 } = context;
+  for (let i = 0; i < length; ++i) {
+    if (position + i === source.length) break;
+    if (i > 0 && source[position + i] !== source[position]) break;
+    const pos = position + i + offset;
+    if (backtracks[pos] & backtrack >>> commandsize) return true;
   }
   return false;
 }
 export function setBacktrack(
   context: Ctx,
-  backtracks: readonly number[],
+  backtrack: number,
   position: number,
   length: number = 1,
 ): void {
   // バックトラックの可能性がなく記録不要の場合もあるが判別が面倒なので省略
+  assert(backtrack & 2);
+  if (length === 0) return;
   const { source } = context;
   if (position === source.length) return;
-  if (length === 0) return;
+  const { backtracks = {}, offset = 0 } = context;
+  for (let i = 0; i < length; ++i) {
+    if (position + i === source.length) break;
+    const pos = position + i + offset;
+    backtracks[pos] |= backtrack >>> commandsize;
+  }
+}
+function reduce(backtracks: readonly number[]): readonly [number, number] {
+  let rbs = 0;
+  let wbs = 0;
   for (const backtrack of backtracks) {
+    if (backtrack & 1) {
+      rbs |= backtrack;
+    }
     if (backtrack & 2) {
-      const { backtracks = {}, offset = 0 } = context;
-      for (let i = 0; i < length; ++i) {
-        if (position + i === source.length) break;
-        const pos = position + i + offset;
-        backtracks[pos] |= 1 << size(backtrack >>> statesize);
-      }
+      wbs |= backtrack;
     }
   }
+  return [rbs, wbs];
 }
 
 function revert(context: Ctx, linebreak: number | undefined): void {
   context.linebreak = linebreak;
 }
-function size(bits: number): number {
-  if (bits === 0) return 0;
-  let p = 0;
-  for (let s = 32 / 2; s > 0; s >>>= 1) {
-    const q = p + s;
-    if (bits >>> q === 0) continue;
-    p = q;
-  }
-  return p + 1;
-}
-assert(size(0 << 0) === 0);
-assert(size(1 << 0) === 1);
-assert(size(1 << 1) === 2);
-assert(size(1 << 30) === 31);
-assert(size(1 << 31) === 32);

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

@@ -1,23 +1,18 @@
 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;
-export function bind<N, P extends Parser<unknown>>(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<unknown>>(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<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> {
   assert(parser);
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
     if (position === source.length) return;
-    const res1 = parser(input);
-    assert(context.position > position || !res1);
-    if (res1 === undefined) return;
+    const result = parser(input);
+    if (result === undefined) return;
     context.range = context.position - position;
-    const res2 = f(res1, context);
-    assert(context.position > position || !res2);
-    return context.position > position
-      ? res2
-      : undefined;
+    return f(result, context);
   });
 }

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

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

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

@@ -2,7 +2,7 @@ import { min } from 'spica/alias';
 import { Parser, Result, List, Data, Ctx, CtxOptions, Node, Context } from '../../data/parser';
 import { clone } from 'spica/assign';
 
-export function reset<P extends Parser<unknown>>(base: CtxOptions, parser: P): P;
+export function reset<P extends Parser>(base: CtxOptions, parser: P): P;
 export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
@@ -13,7 +13,7 @@ export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
     apply(parser, { ...context }, changes, values, true);
 }
 
-export function context<P extends Parser<unknown>>(base: CtxOptions, parser: P): P;
+export function context<P extends Parser>(base: CtxOptions, parser: P): P;
 export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
@@ -23,7 +23,7 @@ export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
     apply(parser, context, changes, values);
 }
 
-function apply<P extends Parser<unknown>>(parser: P, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Node<P>>;
+function apply<P extends Parser>(parser: P, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Node<P>>;
 function apply<N>(parser: Parser<N>, context: Ctx, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<N> {
   for (let i = 0; i < changes.length; ++i) {
     const change = changes[i];
@@ -64,8 +64,8 @@ function apply<N>(parser: Parser<N>, context: Ctx, changes: readonly [string, un
   return result;
 }
 
-export function creation<P extends Parser<unknown>>(cost: number, parser: P): P;
-export function creation(cost: number, parser: Parser<unknown>): Parser<unknown> {
+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;
@@ -85,8 +85,8 @@ export function consume(cost: number, context: Ctx): void {
   resources.clock -= cost;
 }
 
-export function recursion<P extends Parser<unknown>>(recursion: number, parser: P): P;
-export function recursion(recursion: number, parser: Parser<unknown>): Parser<unknown> {
+export function recursion<P extends Parser>(recursion: number, parser: P): P;
+export function recursion(recursion: number, parser: Parser): Parser {
   assert(recursion >= 0);
   return input => {
     const { context } = input;
@@ -102,7 +102,7 @@ export function recursion(recursion: number, parser: Parser<unknown>): Parser<un
   };
 }
 
-export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
+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 => {
@@ -119,8 +119,8 @@ export function precedence<N>(precedence: number, parser: Parser<N>): Parser<N>
   };
 }
 
-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<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;
@@ -140,8 +140,8 @@ export function state<N>(state: number, positive: boolean | Parser<N>, parser?:
   };
 }
 
-export function constraint<P extends Parser<unknown>>(state: number, parser: P): P;
-//export function constraint<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
+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;

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

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