securemark 0.259.1 → 0.259.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.259.1",
+  "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);
     });

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

@@ -9,7 +9,7 @@ export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
   assert(Object.freeze(base));
   const changes = Object.entries(base);
   const values = Array(changes.length);
-  return (source, context) =>
+  return ({ source, context }) =>
     apply(parser, source, ObjectCreate(context), changes, values);
 }
 
@@ -19,7 +19,7 @@ export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
   assert(Object.freeze(base));
   const changes = Object.entries(base);
   const values = Array(changes.length);
-  return (source, context) =>
+  return ({ source, context }) =>
     apply(parser, source, context, changes, values);
 }
 
@@ -41,7 +41,7 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: [str
         context[prop] = change[1];
     }
   }
-  const result = parser(source, context);
+  const result = parser({ source, context });
   if (context) for (let i = 0; i < changes.length; ++i) {
     const change = changes[i];
     const prop = change[0];
@@ -58,11 +58,13 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: [str
 
 export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, cost: number, state: number, parser: P): P;
 export function syntax<T>(syntax: number, prec: number, cost: number, state: number, parser?: Parser<T>): Parser<T> {
-  return creation(cost, precedence(prec, (source, context) => {
+  return creation(cost, precedence(prec, input => {
+    const { source, context } = input;
     if (source === '') return;
     const memo = context.memo ??= new Memo();
     context.memorable ??= ~0;
-    const position = source.length;
+    context.offset ??= 0;
+    const position = source.length + context.offset!;
     const st0 = context.state ?? 0;
     const st1 = context.state = st0 | state;
     const cache = syntax && memo.get(position, syntax, st1);
@@ -70,7 +72,7 @@ export function syntax<T>(syntax: number, prec: number, cost: number, state: num
       ? cache.length === 0
         ? undefined
         : [cache[0], source.slice(cache[1])]
-      : parser!(source, context);
+      : parser!(input);
     if (syntax && st0 & context.memorable!) {
       cache ?? memo.set(position, syntax, st1, eval(result), source.length - exec(result, '').length);
       assert.deepStrictEqual(cache && cache, cache && memo.get(position, syntax, st1));
@@ -89,12 +91,12 @@ export function creation<P extends Parser<unknown>>(cost: number, parser: P): P;
 export function creation(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
   if (typeof cost === 'function') return creation(1, cost);
   assert(cost > 0);
-  return (source, context) => {
-    const { resources = { clock: 1, recursion: 1 } } = context;
+  return input => {
+    const resources = input.context.resources ?? { clock: 1, recursion: 1 };
     if (resources.clock <= 0) throw new Error('Too many creations');
     if (resources.recursion <= 0) throw new Error('Too much recursion');
     --resources.recursion;
-    const result = parser!(source, context);
+    const result = parser!(input);
     ++resources.recursion;
     if (result) {
       resources.clock -= cost;
@@ -106,10 +108,11 @@ export function creation(cost: number | Parser<unknown>, parser?: Parser<unknown
 export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
 export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
   assert(precedence > 0);
-  return (source, context) => {
+  return input => {
+    const { context } = input;
     const p = context.precedence;
     context.precedence = precedence;
-    const result = parser(source, context);
+    const result = parser(input);
     context.precedence = p;
     return result;
   };
@@ -117,9 +120,9 @@ export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T>
 
 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)
+  return input =>
+    f(input.context)
+      ? parser(input)
       : undefined;
 }
 
@@ -131,12 +134,13 @@ export function constraint<T>(state: number, positive: boolean | Parser<T>, pars
     positive = true;
   }
   assert(state);
-  return (source, context) => {
+  return input => {
+    const { context } = input;
     const s = positive
       ? state & context.state!
       : state & ~context.state!;
     return s === state
-      ? parser!(source, context)
+      ? parser!(input)
       : undefined;
   };
 }
@@ -149,12 +153,13 @@ export function state<T>(state: number, positive: boolean | Parser<T>, parser?:
     positive = true;
   }
   assert(state);
-  return (source, context) => {
+  return input => {
+    const { context } = input;
     const s = context.state ?? 0;
     context.state = positive
       ? s | state
       : s & ~state;
-    const result = parser!(source, context);
+    const result = parser!(input);
     context.state = s;
     return result;
   };

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

@@ -6,13 +6,14 @@ export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?
 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) => {
+  return input => {
+    const { source, context } = input;
     let rest = source;
     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);
+      const result = parsers[i]({ source: rest, context });
       assert(check(rest, result));
       if (!result) break;
       nodes = nodes