securemark 0.258.9 → 0.259.2

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];
@@ -56,47 +56,47 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: [str
   return result;
 }
 
-export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, cost: number, parser: P): P;
-export function syntax<T>(syntax: number, precedence: number, cost: number, parser?: Parser<T>): Parser<T> {
-  return creation(cost, (source, context) => {
+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, input => {
+    const { source, context } = input;
     if (source === '') return;
     const memo = context.memo ??= new Memo();
     context.memorable ??= ~0;
-    const p = context.precedence;
-    context.precedence = precedence;
-    const position = source.length;
-    const state = context.state ?? 0;
-    const cache = syntax && memo.get(position, syntax, state);
+    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);
     const result: Result<T> = cache
       ? cache.length === 0
         ? undefined
         : [cache[0], source.slice(cache[1])]
-      : parser!(source, context);
-    if (syntax && state & context.memorable!) {
-      cache ?? memo.set(position, syntax, state, eval(result), source.length - exec(result, '').length);
-      assert.deepStrictEqual(cache && cache, cache && memo.get(position, syntax, state));
+      : 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));
     }
-    if (result && !state && memo.length! >= position) {
-      assert(!(state & context.memorable!));
-      memo.clear(position);
+    if (result && !st0 && memo.length! >= position + 2) {
+      assert(!(st0 & context.memorable!));
+      memo.clear(position + 2);
     }
-    context.precedence = p;
+    context.state = st0;
     return result;
-  });
+  }));
 }
 
 export function creation<P extends Parser<unknown>>(parser: P): P;
 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);
-  if (cost === 0) return parser!;
-  assert(cost >= 0);
-  return (source, context) => {
-    const { resources = { clock: 1, recursion: 1 } } = context;
+  assert(cost > 0);
+  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;
@@ -107,10 +107,12 @@ 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> {
-  return (source, context) => {
+  assert(precedence > 0);
+  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;
   };
@@ -118,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;
 }
 
@@ -132,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;
   };
 }
@@ -150,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

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

@@ -4,12 +4,12 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/sequence', () => {
   describe('sequence', () => {
-    const a: Parser<string, never> = source => {
+    const a: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'a'
         ? [['A'], source.slice(1)]
         : undefined;
     };
-    const b: Parser<string, never> = source => {
+    const b: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'b'
         ? [['B'], source.slice(1)]
         : undefined;
@@ -18,14 +18,14 @@ describe('Unit: combinator/data/parser/sequence', () => {
 
     it('basic', () => {
       const parser = ab;
-      assert.deepStrictEqual(inspect(parser('', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('a', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('b', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('ab', {})), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser('ba', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('aab', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('abb', {})), [['A', 'B'], 'b']);
-      assert.deepStrictEqual(inspect(parser('bba', {})), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'abb', context: {} })), [['A', 'B'], 'b']);
+      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), undefined);
     });
 
   });

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

@@ -6,13 +6,14 @@ export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resu
 export function sequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
-  return (source, context) => {
+  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 === '') return;
       if (context.delimiters?.match(rest, context.precedence)) return;
-      const result = parsers[i](rest, context);
+      const result = parsers[i]({ source: rest, context });
       assert(check(rest, result));
       if (!result) return;
       nodes = nodes

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

@@ -5,12 +5,12 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/some', () => {
   describe('some', () => {
-    const a: Parser<string, never> = source => {
+    const a: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'a'
         ? [['A'], source.slice(1)]
         : undefined;
     };
-    const b: Parser<string, never> = source => {
+    const b: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'b'
         ? [['B'], source.slice(1)]
         : undefined;
@@ -19,17 +19,17 @@ describe('Unit: combinator/data/parser/some', () => {
 
     it('basic', () => {
       const parser = some(ab, /^aaa/);
-      assert.deepStrictEqual(inspect(parser('', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('a', {})), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser('b', {})), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser('ab', {})), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser('ba', {})), [['B', 'A'], '']);
-      assert.deepStrictEqual(inspect(parser('aab', {})), [['A', 'A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser('bba', {})), [['B', 'B', 'A'], '']);
-      assert.deepStrictEqual(inspect(parser('aaa', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('bbb', {})), [['B', 'B', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser('aaab', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('baaa', {})), [['B'], 'aaa']);
+      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), [['B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), [['A', 'A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), [['B', 'B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'aaa', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'bbb', context: {} })), [['B', 'B', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'aaab', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'baaa', context: {} })), [['B'], 'aaa']);
     });
 
   });

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

@@ -16,7 +16,8 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
     matcher: Delimiters.matcher(delimiter),
     precedence,
   }));
-  return (source, context) => {
+  return input => {
+    const { source, context } = input;
     if (source === '') return;
     let rest = source;
     let nodes: T[] | undefined;
@@ -28,7 +29,7 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
       if (rest === '') break;
       if (match(rest)) break;
       if (context.delimiters?.match(rest, context.precedence)) break;
-      const result = parser(rest, context);
+      const result = parser({ source: rest, context });
       assert.doesNotThrow(() => limit < 0 && check(rest, result));
       if (!result) break;
       nodes = nodes

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

@@ -4,17 +4,17 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/subsequence', () => {
   describe('subsequence', () => {
-    const a: Parser<string, never> = source => {
+    const a: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'a'
         ? [['A'], source.slice(1)]
         : undefined;
     };
-    const b: Parser<string, never> = source => {
+    const b: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'b'
         ? [['B'], source.slice(1)]
         : undefined;
     };
-    const c: Parser<string, never> = source => {
+    const c: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'c'
         ? [['C'], source.slice(1)]
         : undefined;
@@ -23,17 +23,17 @@ describe('Unit: combinator/data/parser/subsequence', () => {
 
     it('basic', () => {
       const parser = abc;
-      assert.deepStrictEqual(inspect(parser('', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('a', {})), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser('b', {})), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser('c', {})), [['C'], '']);
-      assert.deepStrictEqual(inspect(parser('ab', {})), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser('ba', {})), [['B'], 'a']);
-      assert.deepStrictEqual(inspect(parser('aab', {})), [['A'], 'ab']);
-      assert.deepStrictEqual(inspect(parser('abb', {})), [['A', 'B'], 'b']);
-      assert.deepStrictEqual(inspect(parser('bba', {})), [['B'], 'ba']);
-      assert.deepStrictEqual(inspect(parser('ac', {})), [['A', 'C'], '']);
-      assert.deepStrictEqual(inspect(parser('bc', {})), [['B', 'C'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'c', context: {} })), [['C'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), [['B'], 'a']);
+      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), [['A'], 'ab']);
+      assert.deepStrictEqual(inspect(parser({ source: 'abb', context: {} })), [['A', 'B'], 'b']);
+      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), [['B'], 'ba']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ac', context: {} })), [['A', 'C'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'bc', context: {} })), [['B', 'C'], '']);
     });
 
   });

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

@@ -4,12 +4,12 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/data/parser/union', () => {
   describe('union', () => {
-    const a: Parser<string, never> = source => {
+    const a: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'a'
         ? [['A'], source.slice(1)]
         : undefined;
     };
-    const b: Parser<string, never> = source => {
+    const b: Parser<string, never> = ({ source }) => {
       return source && source[0] === 'b'
         ? [['B'], source.slice(1)]
         : undefined;
@@ -18,14 +18,14 @@ describe('Unit: combinator/data/parser/union', () => {
 
     it('basic', () => {
       const parser = ab;
-      assert.deepStrictEqual(inspect(parser('', {})), undefined);
-      assert.deepStrictEqual(inspect(parser('a', {})), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser('b', {})), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser('ab', {})), [['A'], 'b']);
-      assert.deepStrictEqual(inspect(parser('ba', {})), [['B'], 'a']);
-      assert.deepStrictEqual(inspect(parser('aab', {})), [['A'], 'ab']);
-      assert.deepStrictEqual(inspect(parser('abb', {})), [['A'], 'bb']);
-      assert.deepStrictEqual(inspect(parser('bba', {})), [['B'], 'ba']);
+      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(parser({ source: 'a', context: {} })), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'b', context: {} })), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ab', context: {} })), [['A'], 'b']);
+      assert.deepStrictEqual(inspect(parser({ source: 'ba', context: {} })), [['B'], 'a']);
+      assert.deepStrictEqual(inspect(parser({ source: 'aab', context: {} })), [['A'], 'ab']);
+      assert.deepStrictEqual(inspect(parser({ source: 'abb', context: {} })), [['A'], 'bb']);
+      assert.deepStrictEqual(inspect(parser({ source: 'bba', context: {} })), [['B'], 'ba']);
     });
 
   });

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

@@ -12,9 +12,9 @@ export function union<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
     default:
       return Function('parsers', [
         '"use strict";',
-        'return (source, context) =>',
+        'return (input, context) =>',
         '0',
-        ...parsers.map((_, i) => `|| parsers[${i}](source, context)`),
+        ...parsers.map((_, i) => `|| parsers[${i}](input, context)`),
       ].join('\n'))(parsers);
   }
 }

package/src/combinator/data/parser.ts

@@ -2,7 +2,11 @@ import { Delimiters } from './parser/context/delimiter';
 import { Memo } from './parser/context/memo';
 
 export type Parser<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
-  = (source: string, context: C) => Result<T, C, D>;
+  = (input: Input<C>) => Result<T, C, D>;
+export interface Input<C extends Ctx = Ctx> {
+  readonly source: string;
+  readonly context: C;
+}
 export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   = readonly [T[], string, C, D]
   | readonly [T[], string]
@@ -12,6 +16,7 @@ export interface Ctx {
     clock: number;
     recursion: number;
   };
+  offset?: number;
   precedence?: number;
   delimiters?: Delimiters;
   state?: number;

package/src/parser/api/bind.ts

@@ -5,7 +5,7 @@ import { eval } from '../../combinator/data/parser';
 import { segment, validate, MAX_INPUT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
-import { backtrackable } from '../context';
+import { State } from '../context';
 import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
@@ -24,7 +24,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   let context: MarkdownParser.Context = {
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
-    memorable: backtrackable,
+    memorable: State.backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   assert(!settings.id);
@@ -77,7 +77,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = eval(header(seg, { header: index === 0 }) || block(seg, context), []);
+      const es = eval(header({ source: seg, context: { header: index === 0 } }) || block({ source: seg, context }), []);
       blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.

package/src/parser/api/header.ts

@@ -12,7 +12,7 @@ export function headers(source: string): string[] {
 }
 
 function parse(source: string): [HTMLElement, string] | [] {
-  const result = h(source, {});
+  const result = h({ source, context: {} });
   const [el] = eval(result, []);
   return el?.tagName === 'ASIDE'
     ? [el, exec(result!)]

package/src/parser/api/normalize.ts

@@ -60,7 +60,7 @@ export const invisibleHTMLEntityNames = [
 ] as const;
 const unreadableHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames.slice(2);
 const unreadableEscapableCharacters = unreadableHTMLEntityNames
-  .map(name => eval(unsafehtmlentity(`&${name};`, {}))![0]);
+  .map(name => eval(unsafehtmlentity({ source: `&${name};`, context: {} }))![0]);
 assert(unreadableEscapableCharacters.length === unreadableHTMLEntityNames.length);
 assert(unreadableEscapableCharacters.every(c => c.length === 1));
 const unreadableEscapableCharacter = new RegExp(`[${

package/src/parser/api/parse.ts

@@ -5,7 +5,7 @@ import { eval } from '../../combinator/data/parser';
 import { segment, validate, MAX_SEGMENT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
-import { backtrackable } from '../context';
+import { State } from '../context';
 import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
@@ -30,13 +30,13 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
     ...context?.resources && {
       resources: context.resources,
     },
-    memorable: backtrackable,
+    memorable: State.backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   const node = frag();
   let index = 0;
   for (const seg of segment(source)) {
-    node.append(...eval(header(seg, { header: index++ === 0 }) || block(seg, context), []));
+    node.append(...eval(header({ source: seg, context: { header: index++ === 0 } }) || block({ source: seg, context }), []));
   }
   assert(opts.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
   if (opts.test) return node;

package/src/parser/autolink.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../debug.test';
 
 describe('Unit: parser/autolink', () => {
   describe('autolink', () => {
-    const parser = (source: string) => some(autolink)(source, {});
+    const parser = (source: string) => some(autolink)({ source, context: {} });
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser(' http://host')), [[' ', '<a href="http://host" target="_blank">http://host</a>'], '']);

package/src/parser/autolink.ts

@@ -7,7 +7,7 @@ export import AutolinkParser = MarkdownParser.AutolinkParser;
 
 const delimiter = /[@#>0-9A-Za-z\n]|\S[#>]/;
 
-export const autolink: AutolinkParser = (source, context) => {
+export const autolink: AutolinkParser = ({ source, context }) => {
   if (source === '') return;
   assert(source[0] !== '\x1B');
   const i = source.search(delimiter);
@@ -15,7 +15,7 @@ export const autolink: AutolinkParser = (source, context) => {
     case -1:
       return [[source], ''];
     case 0:
-      return parser(source, context);
+      return parser({ source, context });
     default:
       return [[source.slice(0, i)], source.slice(i)];
   }

package/src/parser/block/blockquote.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/blockquote', () => {
   describe('blockquote', () => {
-    const parser = (source: string) => some(blockquote)(source, {});
+    const parser = (source: string) => some(blockquote)({ source, context: {} });
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);

package/src/parser/block/blockquote.ts

@@ -37,7 +37,7 @@ const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
     creation(99,
     rewrite(
       some(contentline, opener),
-      convert(unindent, (source, context) => {
+      convert(unindent, ({ source, context }) => {
         const references = html('ol', { class: 'references' });
         const document = parse(source, {
           id: '',

package/src/parser/block/codeblock.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/codeblock', () => {
   describe('codeblock', () => {
-    const parser = (source: string) => some(codeblock)(source, {});
+    const parser = (source: string) => some(codeblock)({ source, context: {} });
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);

package/src/parser/block/codeblock.ts

@@ -70,6 +70,6 @@ export const codeblock: CodeBlockParser = block(validate('```', fmap(
       params.lang
         ? context.caches?.code?.get(`${params.lang ?? ''}\n${body.slice(0, -1)}`)?.cloneNode(true).childNodes ||
           body.slice(0, -1) || undefined
-        : defrag(eval(some(autolink)(body.slice(0, -1), context), [])));
+        : defrag(eval(some(autolink)({ source: body.slice(0, -1), context }), [])));
     return [el];
   })));

package/src/parser/block/dlist.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/dlist', () => {
   describe('dlist', () => {
-    const parser = (source: string) => some(dlist)(source, {});
+    const parser = (source: string) => some(dlist)({ source, context: {} });
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);

package/src/parser/block/extension/aside.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/block/extension/aside', () => {
   describe('aside', () => {
-    const parser = (source: string) => some(aside)(source, {});
+    const parser = (source: string) => some(aside)({ source, context: {} });
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('~~~aside\n~~~')), [['<pre class="invalid" translate="no">~~~aside\n~~~</pre>'], '']);

package/src/parser/block/extension/example.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/block/extension/example', () => {
   describe('example', () => {
-    const parser = (source: string) => some(example)(source, {});
+    const parser = (source: string) => some(example)({ source, context: {} });
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('~~~example/\n~~~')), undefined);

package/src/parser/block/extension/example.ts

@@ -44,7 +44,7 @@ export const example: ExtensionParser.ExampleParser = block(validate('~~~', fmap
           html('aside', { class: 'example', 'data-type': 'math' }, [
             html('pre', { translate: 'no' }, body.slice(0, -1)),
             html('hr'),
-            eval(mathblock(`$$\n${body}$$`, context), [])[0],
+            eval(mathblock({ source: `$$\n${body}$$`, context }), [])[0],
           ]),
         ];
       default:

package/src/parser/block/extension/fig.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/block/extension/fig', () => {
   describe('fig', () => {
-    const parser = (source: string) => some(fig)(source, {});
+    const parser = (source: string) => some(fig)({ source, context: {} });
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('\n!https://host\n')), undefined);

package/src/parser/block/extension/figbase.test.ts

@@ -4,7 +4,7 @@ import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/block/extension/figbase', () => {
   describe('figbase', () => {
-    const parser = (source: string) => some(figbase)(source, {});
+    const parser = (source: string) => some(figbase)({ source, context: {} });
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('\n$-0')), undefined);