securemark 0.259.1 → 0.259.2

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

@@ -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

@@ -36,7 +36,7 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
   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);

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

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

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

@@ -98,7 +98,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'data-invalid-type': 'fence',
           'data-invalid-message': `Invalid trailing line after the closing delimiter "${delim}"`,
         } ||
-        !seg_label(opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context) && {
+        !seg_label({ source: opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context }) && {
           'data-invalid-type': 'label',
           'data-invalid-message': 'Invalid label',
         } ||

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

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

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

@@ -48,7 +48,7 @@ export const message: MessageParser = block(validate('~~~', fmap(
     return [
       html('section', { class: `message`, 'data-type': type }, unshift(
         [html('h1', title(type))],
-        [...segment(body)].reduce((acc, seg) => push(acc, eval(content(seg, context), [])), []))),
+        [...segment(body)].reduce((acc, seg) => push(acc, eval(content({ source: seg, context }), [])), []))),
     ];
   })));
 

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

@@ -3,7 +3,7 @@ import { some } from '../../../combinator';
 
 describe('Unit: parser/block/extension/placeholder', () => {
   describe('placeholder', () => {
-    const parser = (source: string) => some(placeholder)(source, {});
+    const parser = (source: string) => some(placeholder)({ source, context: {} });
 
     it('invalid', () => {
       assert(!parser(''));

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

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

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

@@ -40,7 +40,7 @@ export const table: TableParser = block(validate('~~~', fmap(
     switch (type) {
       case 'grid':
       case undefined:
-        return (eval(parser(body, context)) ?? [html('table')])
+        return (eval(parser({ source: body, context })) ?? [html('table')])
           .map(el => define(el, { 'data-type': type }));
       default:
         return [html('pre', {

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

@@ -3,7 +3,7 @@ import { some } from '../../combinator';
 
 describe('Unit: parser/block/extension', () => {
   describe('extension', () => {
-    const parser = (source: string) => some(extension)(source, {});
+    const parser = (source: string) => some(extension)({ source, context: {} });
 
     it('invalid', () => {
       assert(!parser(''));

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

@@ -6,10 +6,10 @@ import { inspect } from '../../debug.test';
 describe('Unit: parser/block/heading', () => {
   describe('heading', () => {
     const parser = (source: string) => {
-      const result = segment(source, {});
+      const result = segment({ source, context: {} });
       return result
-        ? [eval(result).flatMap(seg => eval<HTMLElement | string>(heading(seg, {}), [seg])), exec(result)] as const
-        : some(heading)(source, {});
+        ? [eval(result).flatMap(seg => eval<HTMLElement | string>(heading({ source: seg, context: {} }), [seg])), exec(result)] as const
+        : some(heading)({ source, context: {} });
     };
 
     it('invalid', () => {

package/src/parser/block/heading.ts

@@ -8,7 +8,7 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
   /^#+[^\S\n]+\S[^\n]*(?:\n#+(?!\S)[^\n]*)*(?:$|\n)/,
-  some(line(source => [[source], ''])))));
+  some(line(({ source }) => [[source], ''])))));
 
 export const heading: HeadingParser = block(rewrite(segment,
   state(State.annotation | State.reference | State.index | State.label | State.link | State.media,

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

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

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

@@ -3,7 +3,7 @@ import { some } from '../../combinator';
 
 describe('Unit: parser/block/ilist', () => {
   describe('ilist', () => {
-    const parser = (source: string) => some(ilist)(source, {});
+    const parser = (source: string) => some(ilist)({ source, context: {} });
 
     it('single', () => {
       assert(!parser('-'));

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

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

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

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

package/src/parser/block/olist.ts

@@ -1,5 +1,6 @@
 import { undefined } from 'spica/global';
 import { OListParser } from '../block';
+import { Parser } from '../../combinator/data/parser';
 import { union, inits, subsequence, some, creation, state, block, line, validate, indent, focus, rewrite, open, match, fallback, lazy, fmap } from '../../combinator';
 import { checkbox, ulist_, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
@@ -11,7 +12,6 @@ import { html, define, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { duffbk } from 'spica/duff';
 import { shift } from 'spica/array';
-import { tuple } from 'spica/tuple';
 
 const openers = {
   '.': /^([0-9]+|[a-z]+|[A-Z]+)(?:-(?!-)[0-9]*)*(?![^\S\n])\.?(?:$|\s)/,
@@ -51,15 +51,15 @@ const list = (type: string, form: string): OListParser.ListParser => fmap(
 const heads = {
   '.': focus(
     openers['.'],
-    source => [[source.trimEnd().split('.', 1)[0] + '.'], '']),
+    ({ source }) => [[source.trimEnd().split('.', 1)[0] + '.'], '']),
   '(': focus(
     openers['('],
-    source => [[source.trimEnd().replace(/^\($/, '(1)').replace(/^\((\w+)$/, '($1)')], '']),
+    ({ source }) => [[source.trimEnd().replace(/^\($/, '(1)').replace(/^\((\w+)$/, '($1)')], '']),
 } as const;
 
 export const invalid = rewrite(
-  inits([contentline, indent((s: string) => [tuple(s), ''] as const)]),
-  source => [[
+  inits([contentline, indent<Parser<string>>(({ source }) => [[source], ''])]),
+  ({ source }) => [[
     '',
     html('span', {
       class: 'invalid',

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

@@ -4,7 +4,7 @@ import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/paragraph', () => {
   describe('paragraph', () => {
-    const parser = (source: string) => some(paragraph)(source, {});
+    const parser = (source: string) => some(paragraph)({ source, context: {} });
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a')), [['<p>a</p>'], '']);