securemark 0.258.9 → 0.259.2

package/markdown.d.ts

@@ -577,6 +577,7 @@ export namespace MarkdownParser {
             InlineParser.AutolinkParser.AnchorParser,
             Parser<HTMLAnchorElement, Context, []>,
             Parser<HTMLAnchorElement, Context, []>,
+            Parser<HTMLAnchorElement, Context, []>,
           ]>,
         ]> {
       }
@@ -842,7 +843,7 @@ export namespace MarkdownParser {
       // { uri }
       // [abc]{uri nofollow}
       Inline<'link'>,
-      Parser<HTMLElement, Context, [
+      Parser<HTMLAnchorElement, Context, [
         LinkParser.MediaLinkParser,
         LinkParser.TextLinkParser,
       ]> {
@@ -850,7 +851,7 @@ export namespace MarkdownParser {
     export namespace LinkParser {
       export interface TextLinkParser extends
         Inline<'link/textlink'>,
-        Parser<HTMLElement, Context, [
+        Parser<HTMLAnchorElement, Context, [
           Parser<(HTMLElement | string)[], Context, [
             InlineParser,
           ]>,
@@ -859,7 +860,7 @@ export namespace MarkdownParser {
       }
       export interface MediaLinkParser extends
         Inline<'link/medialink'>,
-        Parser<HTMLElement, Context, [
+        Parser<HTMLAnchorElement, Context, [
           Parser<HTMLElement[], Context, [
             MediaParser,
             ShortmediaParser,

package/package.json

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

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

@@ -4,14 +4,14 @@ import { inspect } from '../../../debug.test';
 describe('Unit: combinator/block', () => {
   describe('block', () => {
     it('invalid', () => {
-      assert.throws(() => block(_ => [[], '\n'])(' \n'));
+      assert.throws(() => block(_ => [[], '\n'])({ source: ' \n', context: {} }));
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(block(_ => [[], ''])('\n')), [[], '']);
-      assert.deepStrictEqual(inspect(block(_ => [[], ''])(' \n')), [[], '']);
-      assert.deepStrictEqual(inspect(block(_ => [[], ''])('\n\n')), [[], '']);
-      assert.deepStrictEqual(inspect(block(_ => [[], '\n'])('\n\n')), [[], '\n']);
+      assert.deepStrictEqual(inspect(block(_ => [[], ''])({ source: '\n', context: {} })), [[], '']);
+      assert.deepStrictEqual(inspect(block(_ => [[], ''])({ source: ' \n', context: {} })), [[], '']);
+      assert.deepStrictEqual(inspect(block(_ => [[], ''])({ source: '\n\n', context: {} })), [[], '']);
+      assert.deepStrictEqual(inspect(block(_ => [[], '\n'])({ source: '\n\n', context: {} })), [[], '\n']);
     });
 
   });

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

@@ -6,10 +6,11 @@ import { firstline, isEmpty } from './line';
 export function block<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
 export function block<T>(parser: Parser<T>, separation = true): Parser<T> {
   assert(parser);
-  return (source, context = {}) => {
+  return input => {
+    const { source, context } = input;
     if (source === '') return;
     context.memo ??= new Memo();
-    const result = parser(source, context);
+    const result = parser(input);
     if (!result) return;
     const rest = exec(result);
     if (separation && !isEmpty(firstline(rest))) return;

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

@@ -24,10 +24,11 @@ export function validate<T>(patterns: string | RegExp | (string | RegExp)[], has
         ? `|| source.slice(0, ${pattern.length}) === '${pattern}'`
         : `|| /${pattern.source}/${pattern.flags}.test(source)`),
   ].join(''))();
-  return (source, context) => {
+  return input => {
+    const { source } = input;
     if (source === '') return;
     if (!match(source)) return;
-    const result = parser!(source, context);
+    const result = parser!(input);
     assert(check(source, result));
     if (!result) return;
     assert(exec(result).length < source.length);
@@ -40,12 +41,13 @@ export function validate<T>(patterns: string | RegExp | (string | RegExp)[], has
 export function verify<P extends Parser<unknown>>(parser: P, cond: (results: readonly Tree<P>[], rest: string, context: Context<P>) => boolean): P;
 export function verify<T>(parser: Parser<T>, cond: (results: readonly T[], rest: string, context: Ctx) => boolean): Parser<T> {
   assert(parser);
-  return (source, context) => {
+  return input => {
+    const { source } = input;
     if (source === '') return;
-    const result = parser(source, context);
+    const result = parser(input);
     assert(check(source, result));
     if (!result) return;
-    if (!cond(eval(result), exec(result), context)) return;
+    if (!cond(eval(result), exec(result), input.context)) return;
     assert(exec(result).length < source.length);
     return exec(result).length < source.length
       ? result

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

@@ -4,15 +4,15 @@ import { inspect } from '../../../debug.test';
 describe('Unit: combinator/line', () => {
   describe('line', () => {
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])('')), undefined);
+      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: '', context: {} })), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])(' ')), [[], '']);
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])('\n')), [[], '']);
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])('\n\n')), [[], '\n']);
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])(' \n')), [[], '']);
-      assert.deepStrictEqual(inspect(line(_ => [[], '\n'])(' \n')), [[], '']);
+      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: ' ', context: {} })), [[], '']);
+      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: '\n', context: {} })), [[], '']);
+      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: '\n\n', context: {} })), [[], '\n']);
+      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: ' \n', context: {} })), [[], '']);
+      assert.deepStrictEqual(inspect(line(_ => [[], '\n'])({ source: ' \n', context: {} })), [[], '']);
     });
 
   });

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

@@ -5,15 +5,16 @@ import { Memo } from '../../data/parser/context/memo';
 export function line<P extends Parser<unknown>>(parser: P): P;
 export function line<T>(parser: Parser<T>): Parser<T> {
   assert(parser);
-  return (source, context = {}) => {
+  return input => {
+    const { source, context } = input;
     if (source === '') return;
     context.memo ??= new Memo();
     const line = firstline(source);
-    const memo = context.memo!;
-    memo.offset += source.length - line.length;
-    const result = parser(line, context);
+    context.offset ??= 0;
+    context.offset += source.length - line.length;
+    const result = parser({ source: line, context });
     assert(check(line, result));
-    memo.offset -= source.length - line.length;
+    context.offset -= source.length - line.length;
     if (!result) return;
     return isEmpty(exec(result))
       ? [eval(result), source.slice(line.length)]

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

@@ -3,15 +3,16 @@ import { Parser, check } 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 input => {
+    const { source, context } = input;
     if (source === '') return;
     const src = conv(source);
     if (src === '') return [[], ''];
-    const memo = context.memo;
-    memo && (memo.offset += source.length - src.length);
-    const result = parser(src, context);
+    context.offset ??= 0;
+    context.offset += source.length - src.length;
+    const result = parser({ source: src, context });
     assert(check(src, result));
-    memo && (memo.offset -= source.length - src.length);
+    context.offset -= source.length - src.length;
     return result;
   };
 }

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

@@ -3,7 +3,8 @@ import { firstline, isEmpty } from '../constraint/line';
 import { unshift } from 'spica/array';
 
 export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation = true): Parser<string, C, D> {
-  return source => {
+  return input => {
+    const { source } = input;
     if (source === '') return;
     const matches = source.match(opener);
     if (!matches) return;

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

@@ -4,20 +4,20 @@ import { inspect } from '../../../debug.test';
 describe('Unit: combinator/indent', () => {
   describe('indent', () => {
     it('valid', () => {
-      const parser = indent((s, _) => [[s], '']);
-      assert.deepStrictEqual(inspect(parser('', {})), undefined);
-      assert.deepStrictEqual(inspect(parser(' ', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('  ', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('a ', {})), undefined);
-      assert.deepStrictEqual(inspect(parser(' a\n', {})), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(' a ', {})), [['a '], '']);
-      assert.deepStrictEqual(inspect(parser(' a \n', {})), [['a '], '']);
-      assert.deepStrictEqual(inspect(parser('  a', {})), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(' a\n a', {})), [['a\na'], '']);
-      assert.deepStrictEqual(inspect(parser(' a\n  a', {})), [['a\n a'], '']);
-      assert.deepStrictEqual(inspect(parser('  a\n a', {})), [['a'], ' a']);
-      assert.deepStrictEqual(inspect(parser(' \ta', {})), [['\ta'], '']);
-      assert.deepStrictEqual(inspect(parser('\ta', {})), [['a'], '']);
+      const parser = indent(({ source }) => [[source], '']);
+      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: ' ', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: '  ', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'a ', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: ' a\n', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: ' a ', context: {} })), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser({ source: ' a \n', context: {} })), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser({ source: '  a', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: ' a\n a', context: {} })), [['a\na'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: ' a\n  a', context: {} })), [['a\n a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: '  a\n a', context: {} })), [['a'], ' a']);
+      assert.deepStrictEqual(inspect(parser({ source: ' \ta', context: {} })), [['\ta'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: '\ta', context: {} })), [['a'], '']);
     });
 
   });

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

@@ -17,14 +17,14 @@ export function indent<T>(opener: RegExp | Parser<T>, parser?: Parser<T> | boole
     opener,
     memoize(
     ([indent]) =>
-      some(line(open(indent, source => [[source], '']))),
+      some(line(open(indent, ({ source }) => [[source], '']))),
     ([indent]) => indent.length * 2 + +(indent[0] === ' '), [])), separation),
     (lines, rest, context) => {
       assert(parser = parser as Parser<T>);
-      const memo = context.memo;
-      memo && (memo.offset += rest.length);
-      const result = parser(trimBlockEnd(lines.join('')), context);
-      memo && (memo.offset -= rest.length);
+      context.offset ??= 0;
+      context.offset += rest.length;
+      const result = parser({ source: trimBlockEnd(lines.join('')), context });
+      context.offset -= rest.length;
       return result && exec(result) === ''
         ? [eval(result), rest]
         : undefined;

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

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

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

@@ -4,12 +4,13 @@ import { Parser, exec, check } from '../../data/parser';
 export function match<P extends Parser<unknown>>(pattern: RegExp, f: (matched: RegExpMatchArray) => P): P;
 export function match<T>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<T>): Parser<T> {
   assert(!pattern.flags.match(/[gmy]/) && pattern.source.startsWith('^'));
-  return (source, context) => {
+  return input => {
+    const { source } = input;
     if (source === '') return;
     const param = source.match(pattern);
     if (!param) return;
     assert(source.startsWith(param[0]));
-    const result = f(param)(source, context);
+    const result = f(param)(input);
     assert(check(source, result, false));
     if (!result) return;
     return exec(result).length < source.length && exec(result).length <= source.length

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

@@ -1,14 +1,14 @@
-import { Parser, Result, Ctx, Tree, Context } from '../../data/parser';
+import { Parser, Input, Result, Tree, Context } from '../../data/parser';
 
-export function recover<P extends Parser<unknown>>(parser: P, fallback: (source: string, context: Context<P>, reason: unknown) => Result<Tree<P>>): P;
-export function recover<T>(parser: Parser<T>, fallback: (source: string, context: Ctx, reason: unknown) => Result<T>): Parser<T> {
-  return (source, context) => {
+export function recover<P extends Parser<unknown>>(parser: P, fallback: (input: Input<Context<P>>, reason: unknown) => Result<Tree<P>>): P;
+export function recover<T>(parser: Parser<T>, fallback: (input: Input, reason: unknown) => Result<T>): Parser<T> {
+  return input => {
     try {
-      return parser(source, context);
+      return parser(input);
     }
     catch (reason) {
       assert(reason instanceof Error && reason.name === 'AssertionError' && !+console.error(reason) && eval(`throw new Error("${reason.name}")`) || 1);
-      return fallback(source, context, reason);
+      return fallback(input, reason);
     }
   };
 }

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

@@ -8,16 +8,17 @@ 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 input => {
+    const { source, context } = input;
     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);
+    context.offset ??= 0;
+    context.offset += source.length - src.length;
+    const result = parser({ source: src, context });
     assert(check(src, result));
-    memo && (memo.offset -= source.length - src.length);
+    context.offset -= source.length - src.length;
     if (!result) return;
     assert(exec(result).length < src.length);
     return exec(result).length < src.length
@@ -31,21 +32,23 @@ 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 input => {
+    const { source, context } = input;
     if (source === '') return;
     const memo = context.memo;
     context.memo = undefined;
-    const res1 = scope(source, context);
+    const res1 = scope(input);
     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);
+    context.offset ??= 0;
+    context.offset += source.length - src.length;
+    const res2 = parser({ source: src, context });
     assert(check(src, res2));
-    memo && (memo.offset -= source.length - src.length);
+    context.offset -= source.length - src.length;
     if (!res2) return;
     assert(exec(res2) === '');
     return exec(res2).length < src.length

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

@@ -1,5 +1,5 @@
 import { undefined } from 'spica/global';
-import { Parser, Result, Ctx, Tree, Context, SubParsers, SubTree, IntermediateParser, eval, exec, check } from '../../data/parser';
+import { Parser, Input, Result, Ctx, Tree, Context, SubParsers, SubTree, IntermediateParser, eval, exec, check } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 import { unshift, push } from 'spica/array';
 
@@ -38,19 +38,20 @@ export function surround<T>(
     case 'object':
       return surround(opener, parser, match(closer), optional, f, g);
   }
-  return (lmr_, context) => {
+  return input => {
+    const { source: lmr_, context } = input;
     if (lmr_ === '') return;
-    const res1 = opener(lmr_, context);
+    const res1 = opener({ source: lmr_, context });
     assert(check(lmr_, res1, false));
     if (!res1) return;
     const rl = eval(res1);
     const mr_ = exec(res1);
-    const res2 = mr_ !== '' ? parser(mr_, context) : undefined;
+    const res2 = mr_ !== '' ? parser({ source: mr_, context }) : undefined;
     assert(check(mr_, res2));
     const rm = eval(res2);
     const r_ = exec(res2, mr_);
     if (!rm && !optional) return;
-    const res3 = closer(r_, context);
+    const res3 = closer({ source: r_, context });
     assert(check(r_, res3, false));
     const rr = eval(res3);
     const rest = exec(res3, r_);
@@ -65,12 +66,12 @@ export function surround<T>(
   };
 }
 
-function match(pattern: string | RegExp): (source: string, context: Ctx) => [never[], string] | undefined {
+function match(pattern: string | RegExp): (input: Input) => [never[], string] | undefined {
   switch (typeof pattern) {
     case 'string':
-      return source => source.slice(0, pattern.length) === pattern ? [[], source.slice(pattern.length)] : undefined;
+      return ({ source }) => source.slice(0, pattern.length) === pattern ? [[], source.slice(pattern.length)] : undefined;
     case 'object':
-      return source => {
+      return ({ source }) => {
         const m = source.match(pattern);
         return m
           ? [[], source.slice(m[0].length)]

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

@@ -4,15 +4,15 @@ import { inspect } from '../../../debug.test';
 describe('Unit: combinator/trim', () => {
   describe('trim', () => {
     it('', () => {
-      const parser = trim(s => [[s], '']);
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('a\n')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('a ')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('a \n')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(' a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(' a ')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(' a \n b \n')), [['a \n b'], '']);
+      const parser = trim(({ source }) => [[source], '']);
+      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'a\n', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'a ', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'a \n', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: ' a', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: ' a ', context: {} })), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: ' a \n b \n', context: {} })), [['a \n b'], '']);
     });
 
   });

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

@@ -7,9 +7,10 @@ export function bind<T, P extends Parser<unknown>>(parser: Parser<T, Context<P>,
 export function bind<U, P extends Parser<unknown>>(parser: P, f: (nodes: Tree<P>[], rest: string, context: Context<P>) => Result<U, Context<P>, SubParsers<P>>): Parser<U, Context<P>, SubParsers<P>>;
 export function bind<T, U>(parser: Parser<T>, f: (nodes: T[], rest: string, context: Ctx) => Result<U>): Parser<U> {
   assert(parser);
-  return (source, context) => {
+  return input => {
+    const { source, context } = input;
     if (source === '') return;
-    const res1 = parser(source, context);
+    const res1 = parser(input);
     assert(check(source, res1));
     if (!res1) return;
     const res2 = f(eval(res1), exec(res1), context);

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

@@ -3,14 +3,13 @@ export class Memo {
   public get length(): number {
     return this.memory.length;
   }
-  public offset = 0;
   public get(
     position: number,
     syntax: number,
     state: number,
   ): readonly [any[], number] | readonly [] | undefined {
     //console.log('get', position + this.offset, syntax, state, this.memory[position + this.offset - 1]?.[`${syntax}:${state}`]);;
-    const cache = this.memory[position + this.offset - 1]?.[`${syntax}:${state}`];
+    const cache = this.memory[position - 1]?.[`${syntax}:${state}`];
     return cache?.length === 2
       ? [cache[0].slice(), cache[1]]
       : cache;
@@ -22,7 +21,7 @@ export class Memo {
     nodes: any[] | undefined,
     offset: number,
   ): void {
-    const record = this.memory[position + this.offset - 1] ??= {};
+    const record = this.memory[position - 1] ??= {};
     assert(!record[`${syntax}:${state}`]);
     record[`${syntax}:${state}`] = nodes
       ? [nodes.slice(), offset]
@@ -31,7 +30,7 @@ export class Memo {
   }
   public clear(position: number): void {
     const memory = this.memory;
-    for (let i = position + this.offset, len = memory.length; i < len; ++i) {
+    for (let i = position, len = memory.length; i < len; ++i) {
       memory.pop();
     }
     //console.log('clear', position + this.offset + 1);

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

@@ -10,26 +10,26 @@ describe('Unit: combinator/data/parser/context', () => {
 
   describe('reset', () => {
     const parser: Parser<number> = some(creation(
-      (s, context) => [[context.resources?.clock ?? NaN], s.slice(1)]));
+      ({ source, context }) => [[context.resources?.clock ?? NaN], source.slice(1)]));
 
     it('root', () => {
       const base: Context = { resources: { clock: 3, recursion: 1 } };
       const ctx: Context = {};
-      assert.deepStrictEqual(reset(base, parser)('123', ctx), [[3, 2, 1], '']);
+      assert.deepStrictEqual(reset(base, parser)({ source: '123', context: ctx }), [[3, 2, 1], '']);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === undefined);
-      assert.throws(() => reset(base, parser)('1234', ctx));
+      assert.throws(() => reset(base, parser)({ source: '1234', context: ctx }));
       assert(ctx.resources?.clock === undefined);
-      assert.deepStrictEqual(reset(base, parser)('123', ctx), [[3, 2, 1], '']);
+      assert.deepStrictEqual(reset(base, parser)({ source: '123', context: ctx }), [[3, 2, 1], '']);
     });
 
     it('node', () => {
       const base: Context = { resources: { clock: 3, recursion: 1 } };
       const ctx: Context = { resources: { clock: 1, recursion: 1 } };
-      assert.deepStrictEqual(reset(base, parser)('1', ctx), [[1], '']);
+      assert.deepStrictEqual(reset(base, parser)({ source: '1', context: ctx }), [[1], '']);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === 0);
-      assert.throws(() => reset(base, parser)('1', ctx));
+      assert.throws(() => reset(base, parser)({ source: '1', context: ctx }));
       assert(ctx.resources?.clock === 0);
     });
 
@@ -37,15 +37,15 @@ describe('Unit: combinator/data/parser/context', () => {
 
   describe('context', () => {
     const parser: Parser<boolean, Context> = some(creation(
-      (s, context) => [[context.status!], s.slice(1)]));
+      ({ source, context }) => [[context.status!], source.slice(1)]));
 
     it('', () => {
       const base: Context = { status: true };
       const ctx: Context = { resources: { clock: 3, recursion: 1 } };
-      assert.deepStrictEqual(context(base, parser)('123', ctx), [[true, true, true], '']);
+      assert.deepStrictEqual(context(base, parser)({ source: '123', context: ctx }), [[true, true, true], '']);
       assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);
-      assert.throws(() => reset(base, parser)('1', ctx));
+      assert.throws(() => reset(base, parser)({ source: '1', context: ctx }));
       assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);
     });