securemark 0.291.0 → 0.292.0

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

@@ -1,70 +1,71 @@
 import { table } from './table';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/table', () => {
   describe('table', () => {
-    const parser = (source: string) => some(table)({ source, context: {} });
+    const parser = (source: string) => some(table)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('\n')), undefined);
-      assert.deepStrictEqual(inspect(parser('|')), undefined);
-      assert.deepStrictEqual(inspect(parser('||')), undefined);
-      assert.deepStrictEqual(inspect(parser('|||')), undefined);
-      assert.deepStrictEqual(inspect(parser('|\n|')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h\n')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h\n|')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h\n|b')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h\n|-\nb')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h\n|-\n |b')), undefined);
-      assert.deepStrictEqual(inspect(parser('|h\n |-\n|b')), undefined);
-      assert.deepStrictEqual(inspect(parser(' |h\n|-\n|b')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('||'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|||'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|\n|'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h\n|'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h\n|b'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h\n|-\nb'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h\n|-\n |b'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('|h\n |-\n|b'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' |h\n|-\n|b'), ctx), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('|\n|\n|')), [['<table><thead><tr></tr></thead><tbody><tr class="invalid"><td>|</td></tr><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|\n|-\n|')), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('||\n|-|\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|||\n|-|-|\n|||')), [['<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|"|\n|-\n|')), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|`|\n|-\n|')), [['<table><thead><tr><th>`</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|`|`|\n|-\n|')), [['<table><thead><tr><th><code data-src="`|`">|</code></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|((|\n|-\n|')), [['<table><thead><tr><th>((</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|${|\n|-\n|')), [['<table><thead><tr><th>${</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|a|b|\n|-|-|\n|1|2|')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|a|b\n|-|-\n|1|2')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|a|\n|-|\n|1|')), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|a\n|-\n|1')), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('||\n|-\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\ ')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\\n')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr><tr><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|| \n|- \n|| ')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|| \n|-| \n|| ')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|\n|\n|'), ctx), [['<table><thead><tr></tr></thead><tbody><tr class="invalid"><td>|</td></tr><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|\n|-\n|'), ctx), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('||\n|-|\n||'), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|||\n|-|-|\n|||'), ctx), [['<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|"|\n|-\n|'), ctx), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|`|`|\n|-\n|'), ctx), [['<table><thead><tr><th><code data-src="`|`">|</code></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|((|\n|-\n|'), ctx), [['<table><thead><tr><th>((</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|${|\n|-\n|'), ctx), [['<table><thead><tr><th>${</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|a|b|\n|-|-|\n|1|2|'), ctx), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|a|b\n|-|-\n|1|2'), ctx), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|a|\n|-|\n|1|'), ctx), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|a\n|-\n|1'), ctx), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('||\n|-\n||'), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\'), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\ '), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\\n'), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('||\n|-\n||\\\n||'), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|| \n|- \n|| '), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|| \n|-| \n|| '), ctx), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
     });
 
     it('align', () => {
-      assert.deepStrictEqual(inspect(parser('|h|\n|:-|\n|b|')), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td align="start">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|\n|-:|\n|b|')), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td align="end">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|\n|:-:|\n|b|')), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td align="center">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|-|\n|b|b|')), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|:-|\n|b|b|')), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|:-:|\n|b|b|')), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="center">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|-:|\n|b|b|')), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="end">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|h|h|\n|:-:|:-|-:|\n|b|b|b|')), [['<table><thead><tr><th>h</th><th>h</th><th>h</th></tr></thead><tbody><tr><td align="center">b</td><td align="start">b</td><td align="end">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|\n|b|b|')), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|-|\n|b|b|')), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|\n|:-|\n|b|'), ctx), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td align="start">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|\n|-:|\n|b|'), ctx), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td align="end">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|\n|:-:|\n|b|'), ctx), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td align="center">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|-|\n|b|b|'), ctx), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|:-|\n|b|b|'), ctx), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|:-:|\n|b|b|'), ctx), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="center">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|-:|\n|b|b|'), ctx), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="end">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|h|h|\n|:-:|:-|-:|\n|b|b|b|'), ctx), [['<table><thead><tr><th>h</th><th>h</th><th>h</th></tr></thead><tbody><tr><td align="center">b</td><td align="start">b</td><td align="end">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|\n|b|b|'), ctx), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|h|h|\n|:-|-|\n|b|b|'), ctx), [['<table><thead><tr><th>h</th><th>h</th></tr></thead><tbody><tr><td align="start">b</td><td align="start">b</td></tr></tbody></table>'], '']);
     });
 
     it('trim', () => {
-      assert.deepStrictEqual(inspect(parser('|  h  \n|- \n|  b  ')), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|  h  | \n|- \n|  b  | ')), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|\\  h  \\\n|- \n|\\  b  \\')), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
-      assert.deepStrictEqual(inspect(parser('|\\  h  \\ \n|- \n|\\  b  \\ | ')), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|  h  \n|- \n|  b  '), ctx), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|  h  | \n|- \n|  b  | '), ctx), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|\\  h  \\\n|- \n|\\  b  \\'), ctx), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|\\  h  \\ \n|- \n|\\  b  \\ | '), ctx), [['<table><thead><tr><th>h</th></tr></thead><tbody><tr><td>b</td></tr></tbody></table>'], '']);
     });
 
   });

package/src/parser/block/table.ts

@@ -29,20 +29,20 @@ export const table: TableParser = lazy(() => block(fmap(validate(
 const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => fallback(fmap(
   line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
   es => [html('tr', es)]),
-  rewrite(contentline, ({ source }) => [[
+  rewrite(contentline, ({ context: { source } }) => [[
     html('tr', {
       class: 'invalid',
       ...invalid('table-row', 'syntax', 'Missing the start symbol of the table row'),
     }, [html('td', source.replace('\n', ''))])
-  ], '']));
+  ]]));
 
 const align: AlignParser = fmap(open(
   '|',
   union([
-    focus(/^:-+:?/, ({ source }) =>
-      [[source[source.length - 1] === ':' ? 'center' : 'start'], ''], false),
-    focus(/^-+:?/, ({ source }) =>
-      [[source[source.length - 1] === ':' ? 'end' : ''], ''], false),
+    focus(/^:-+:?/, ({ context: { source } }) =>
+      [[source.at(-1) === ':' ? 'center' : 'start']], false),
+    focus(/^-+:?/, ({ context: { source } }) =>
+      [[source.at(-1) === ':' ? 'end' : '']], false),
   ])),
   ns => [html('td', defrag(ns))]);
 

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

@@ -1,81 +1,83 @@
 import { ulist } from './ulist';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/ulist', () => {
   describe('ulist', () => {
-    const parser = (source: string) => some(ulist)({ source, context: {} });
+    const parser = (source: string) => some(ulist)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('\n')), undefined);
-      assert.deepStrictEqual(inspect(parser('-')), undefined);
-      assert.deepStrictEqual(inspect(parser('--')), undefined);
-      assert.deepStrictEqual(inspect(parser('-0')), undefined);
-      assert.deepStrictEqual(inspect(parser('-a')), undefined);
-      assert.deepStrictEqual(inspect(parser('-[]')), undefined);
-      assert.deepStrictEqual(inspect(parser('-[ ]')), undefined);
-      assert.deepStrictEqual(inspect(parser('-[x]')), undefined);
-      assert.deepStrictEqual(inspect(parser('-\n')), undefined);
-      assert.deepStrictEqual(inspect(parser(' - ')), undefined);
-      assert.deepStrictEqual(inspect(parser('+')), undefined);
-      assert.deepStrictEqual(inspect(parser('*')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('--'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-0'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-a'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-[]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-[ ]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-[x]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('-\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' - '), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('+'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('*'), ctx), undefined);
     });
 
     it('single', () => {
       // pending
-      assert.deepStrictEqual(inspect(parser('- ')), [['<ul><li></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- '), ctx), [['<ul><li></li></ul>'], '']);
       // filled
-      assert.deepStrictEqual(inspect(parser('- \\')), [['<ul><li id="index::\\">\\</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- \\\n')), [['<ul><li id="index::\\">\\</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- -')), [['<ul><li id="index::-">-</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- -\n')), [['<ul><li id="index::-">-</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- \\'), ctx), [['<ul><li id="index::\\">\\</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- \\\n'), ctx), [['<ul><li id="index::\\">\\</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- -'), ctx), [['<ul><li id="index::-">-</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- -\n'), ctx), [['<ul><li id="index::-">-</li></ul>'], '']);
     });
 
     it('multiple', () => {
       // pending
-      assert.deepStrictEqual(inspect(parser('-\n-')), [['<ul><li></li><li></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n-'), ctx), [['<ul><li></li><li></li></ul>'], '']);
       // filled
-      assert.deepStrictEqual(inspect(parser('- 1\n- 2')), [['<ul><li id="index::1">1</li><li id="index::2">2</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n- 2\n- 3')), [['<ul><li id="index::1">1</li><li id="index::2">2</li><li id="index::3">3</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n- 2'), ctx), [['<ul><li id="index::1">1</li><li id="index::2">2</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n- 2\n- 3'), ctx), [['<ul><li id="index::1">1</li><li id="index::2">2</li><li id="index::3">3</li></ul>'], '']);
       // invalid
-      assert.deepStrictEqual(inspect(parser('-\n+')), [['<ul><li></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('-\n0')), [['<ul><li></li><li id="index::0"><span class="invalid">0</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n+'), ctx), [['<ul><li></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n0'), ctx), [['<ul><li></li><li id="index::0"><span class="invalid">0</span></li></ul>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('-\n -')), [['<ul><li><br><ul><li></li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2')), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n- 3')), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li><li id="index::3">3</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n - 3')), [['<ul><li id="index::1">1<ul><li id="index::2">2</li><li id="index::3">3</li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n  - 3')), [['<ul><li id="index::1">1<ul><li id="index::2">2<ul><li id="index::3">3</li></ul></li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n  - 2\n - 3')), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li><li id="index::-_3"><span class="invalid"> - 3</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('-\n -\n +\n -\n +\n+')), [['<ul><li><br><ul><li></li><li id="index::+"><span class="invalid">+</span></li><li></li><li id="index::+"><span class="invalid">+</span></li></ul></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n + 2')), [['<ul><li id="index::1">1<ul class="invalid"><li>2</li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0')), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0.')), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0. ')), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- 1\n 0. 2')), [['<ul><li id="index::1">1<ol><li id="index::2">2</li></ol></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- a [#b]')), [['<ul><li id="index::a_b">a <a class="index" href="#index::b">b</a></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- http://host\\')), [['<ul><li id="index::http://host\\"><a class="url" href="http://host\\" target="_blank">http://host\\</a></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- !http://host')), [['<ul><li id="index::!http://host">!<a class="url" href="http://host" target="_blank">http://host</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n -'), ctx), [['<ul><li><br><ul><li></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n- 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li><li id="index::3">3</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n - 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li><li id="index::3">3</li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n - 2\n  - 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2<ul><li id="index::3">3</li></ul></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n  - 2\n - 3'), ctx), [['<ul><li id="index::1">1<ul><li id="index::2">2</li></ul></li><li id="index::-_3"><span class="invalid"> - 3</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('-\n -\n +\n -\n +\n+'), ctx), [['<ul><li><br><ul><li></li><li id="index::+"><span class="invalid">+</span></li><li></li><li id="index::+"><span class="invalid">+</span></li></ul></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n + 2'), ctx), [['<ul><li id="index::1">1<ul class="invalid"><li>2</li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0'), ctx), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0.'), ctx), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0. '), ctx), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- 1\n 0. 2'), ctx), [['<ul><li id="index::1">1<ol><li id="index::2">2</li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [#b]'), ctx), [['<ul><li id="index::a_b">a <a class="index" href="#index::b">b</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- http://host\\'), ctx), [['<ul><li id="index::http://host\\"><a class="url" href="http://host\\" target="_blank">http://host\\</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- !http://host'), ctx), [['<ul><li id="index::!http://host">!<a class="url" href="http://host" target="_blank">http://host</a></li></ul>'], '']);
     });
 
     it('checkbox', () => {
-      assert.deepStrictEqual(inspect(parser('- [ ]')), [['<ul class="checklist"><li><span class="checkbox">☐</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [x]')), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [X]')), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [X] 1')), [['<ul class="checklist"><li id="index::1"><span class="checkbox">☑</span>1</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [ ]'), ctx), [['<ul class="checklist"><li><span class="checkbox">☐</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [x]'), ctx), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [X]'), ctx), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [X] 1'), ctx), [['<ul class="checklist"><li id="index::1"><span class="checkbox">☑</span>1</li></ul>'], '']);
     });
 
     it('indexer', () => {
-      assert.deepStrictEqual(inspect(parser('- [|a]')), [['<ul><li id="index::[|a]">[|a]</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- a [|]')), [['<ul><li>a<span class="indexer" data-index=""></span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- a [|b]')), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [ ] [|a]')), [['<ul class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span>[|a]</li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- [ ] a [|b]')), [['<ul class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- a [|]\n - c [|d]')), [['<ul><li>a<span class="indexer" data-index=""></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
-      assert.deepStrictEqual(inspect(parser('- a [|b]\n - c [|d]')), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [|a]'), ctx), [['<ul><li id="index::[|a]">[|a]</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [|]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [|b]'), ctx), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [ ] [|a]'), ctx), [['<ul class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span>[|a]</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [ ] a [|b]'), ctx), [['<ul class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [|]\n - c [|d]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [|b]\n - c [|d]'), ctx), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
     });
 
   });

package/src/parser/block/ulist.ts

@@ -31,9 +31,9 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
 
 export const checkbox = focus(
   /^\[[xX ]\](?=$|\s)/,
-  ({ source }) => [[
+  ({ context: { source } }) => [[
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
-  ], '']);
+  ]]);
 
 export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | string)[] {
   return ns.length === 1

package/src/parser/block.ts

@@ -42,7 +42,7 @@ export const block: BlockParser = reset(
   {
     resources: {
       // バックトラックのせいで文字数制限を受けないようにする。
-      clock: MAX_SEGMENT_SIZE * 11 + 1,
+      clock: MAX_SEGMENT_SIZE * 1,
       recursions: [
         10 || Recursion.block,
         20 || Recursion.blockquote,
@@ -52,6 +52,7 @@ export const block: BlockParser = reset(
         20 || Recursion.terminal,
       ],
     },
+    backtracks: {},
   },
   error(union([
     emptyline,
@@ -75,9 +76,9 @@ export const block: BlockParser = reset(
 function error(parser: BlockParser): BlockParser {
   const reg = new RegExp(String.raw`^${Command.Error}.*\n`)
   return recover<BlockParser>(fallback(
-    open(Command.Error, ({ source }) => { throw new Error(source.split('\n', 1)[0]); }),
+    open(Command.Error, ({ context: { source, position } }) => { throw new Error(source.slice(position).split('\n', 1)[0]); }),
     parser),
-    ({ source, context: { id } }, reason) => [[
+    ({ context: { source, position, id } }, reason) => [[
       html('h1',
         {
           id: id !== '' ? `error:${rnd0Z(8)}` : undefined,
@@ -91,9 +92,9 @@ function error(parser: BlockParser): BlockParser {
           class: 'error',
           translate: 'no',
         },
-        source
+        source.slice(position)
           .replace(reg, '')
           .slice(0, 1001)
           .replace(/^(.{997}).{4}$/s, '$1...') || undefined),
-    ], '']);
+    ]]);
 }

package/src/parser/context.ts

@@ -38,6 +38,7 @@ export const enum Backtrack {
 
 export const enum Command {
   Error = '\x07',
+  Cancel = '\x18',
   Escape = '\x1B',
   Separator = '\x1F',
 }

package/src/parser/header.test.ts

@@ -1,34 +1,35 @@
 import { header } from './header';
-import { some } from '../combinator';
+import { input } from '../combinator/data/parser';
 import { inspect } from '../debug.test';
 
 describe('Unit: parser/header', () => {
   describe('header', () => {
-    const parser = (source: string) => some(header)({ source, context: {} });
+    const parser = (source: string) => header(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('---')), undefined);
-      assert.deepStrictEqual(inspect(parser('---\n')), undefined);
-      assert.deepStrictEqual(inspect(parser('---\n---')), [['<pre class="invalid" translate="no">---\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\n')), [['<pre class="invalid" translate="no">---\na: b\n</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\n---c')), [['<pre class="invalid" translate="no">---\na: b\n---c</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\n---\nc')), undefined);
-      assert.deepStrictEqual(inspect(parser('---\r \na: b\n---')), undefined);
-      assert.deepStrictEqual(inspect(parser('---\na:\rb\n---')), [['<pre class="invalid" translate="no">---\na:\nb\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\r \n---')), [['<pre class="invalid" translate="no">---\na: b\n \n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\n\n---')), undefined);
-      assert.deepStrictEqual(inspect(parser('---\n \n---')), undefined);
-      assert.deepStrictEqual(inspect(parser('---\n-\n---')), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('----\na: b\n----')), [['<pre class="invalid" translate="no">----\na: b\n----</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser(`---\n${'a: b\n'.repeat(101)}---`)), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('---'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('---\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('---\n---'), ctx), [['<pre class="invalid" translate="no">---\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n'), ctx), [['<pre class="invalid" translate="no">---\na: b\n</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n---c'), ctx), [['<pre class="invalid" translate="no">---\na: b\n---c</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n---\nc'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('---\r \na: b\n---'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('---\na:\rb\n---'), ctx), [['<pre class="invalid" translate="no">---\na:\nb\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\r \n---'), ctx), [['<pre class="invalid" translate="no">---\na: b\n \n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\n\n---'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('---\n \n---'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('---\n-\n---'), ctx), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('----\na: b\n----'), ctx), [['<pre class="invalid" translate="no">----\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser(`---\n${'a: b\n'.repeat(101)}---`), ctx), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('---\na: b\n---')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\n---\n')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\nC: D e\n---\n')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser('--- \r\na: b \r\n--- \r\n \r\n \r\na')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], ' \r\na']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n---'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n---\n'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\nC: D e\n---\n'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser('--- \r\na: b \r\n--- \r\n \r\n \r\na'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], ' \r\na']);
     });
 
   });

package/src/parser/header.ts

@@ -10,8 +10,16 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
   /^---+[^\S\v\f\r\n]*\r?\n[^\S\n]*(?=\S)/,
   inits([
     rewrite(
-      ({ source, context }) =>
-        [[], context.header ?? true ? source.slice(segment(source).next().value!.length) : ''],
+      ({ context }) => {
+        const { source } = context;
+        if (context.header ?? true) {
+          context.position += segment(source).next().value!.length;
+        }
+        else {
+          context.position = source.length;
+        }
+        return [[]];
+      },
       block(
         union([
           validate(({ context }) => context.header ?? true,
@@ -28,20 +36,24 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
                   ])),
                 ]),
               ]), false))),
-          ({ source }) => [[
-            html('pre', {
-              class: 'invalid',
-              translate: 'no',
-              ...invalid('header', 'syntax', 'Invalid syntax'),
-            }, normalize(source)),
-          ], ''],
+          ({ context }) => {
+            const { source, position } = context;
+            context.position += source.length;
+            return [[
+              html('pre', {
+                class: 'invalid',
+                translate: 'no',
+                ...invalid('header', 'syntax', 'Invalid syntax'),
+              }, normalize(source.slice(position))),
+            ]];
+          },
         ]))),
     clear(str(/^[^\S\v\f\r\n]*\r?\n/)),
   ])));
 
-const field: MarkdownParser.HeaderParser.FieldParser = line(({ source }) => {
-  const name = source.slice(0, source.indexOf(':'));
-  const value = source.slice(name.length + 1).trim();
+const field: MarkdownParser.HeaderParser.FieldParser = line(({ context: { source, position } }) => {
+  const name = source.slice(position, source.indexOf(':', position));
+  const value = source.slice(position + name.length + 1).trim();
   return [[
     html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
       html('span', { class: 'field-name' }, name),
@@ -49,5 +61,5 @@ const field: MarkdownParser.HeaderParser.FieldParser = line(({ source }) => {
       html('span', { class: 'field-value' }, value),
       '\n',
     ]),
-  ], ''];
+  ]];
 });