securemark 0.295.0 → 0.295.2

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

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

package/src/parser/block/table.ts

@@ -1,5 +1,5 @@
 import { TableParser } from '../block';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, sequence, some, block, line, validate, focus, rewrite, surround, open, close, fallback, lazy, fmap } from '../../combinator';
 import { inline, media, medialink, shortmedia } from '../inline';
 import { contentline } from '../source';
@@ -21,7 +21,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
     some(row(some(data), true)),
   ])),
   rows => new List([
-    new Data(html('table', [
+    new Node(html('table', [
       html('thead', [rows.shift()!.value]),
       html('tbody', unwrap(format(rows))),
     ])),
@@ -29,9 +29,9 @@ export const table: TableParser = lazy(() => block(fmap(validate(
 
 const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => fallback(fmap(
   line(surround(/(?=\|)/y, some(union([parser])), /\|?\s*$/y, optional)),
-  ns => new List([new Data(html('tr', unwrap(ns)))])),
+  ns => new List([new Node(html('tr', unwrap(ns)))])),
   rewrite(contentline, ({ context: { source } }) => new List([
-    new Data(html('tr', {
+    new Node(html('tr', {
       class: 'invalid',
       ...invalid('table-row', 'syntax', 'Missing the start symbol of the table row'),
     }, [html('td', source.replace('\n', ''))]))
@@ -40,12 +40,12 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
 const align: AlignParser = fmap(open(
   '|',
   union([
-    focus(/:-+:?/y, ({ context: { source, position, range = 0 } }) =>
-      new List([new Data(source[position + range - 1] === ':' ? 'center' : 'start')]), false),
-    focus(/-+:?/y, ({ context: { source, position, range = 0 } }) =>
-      new List([new Data(source[position + range - 1] === ':' ? 'end' : '')]), false),
+    focus(/:-+:?/y, ({ context: { source, position, range } }) =>
+      new List([new Node(source[position + range - 1] === ':' ? 'center' : 'start')]), false),
+    focus(/-+:?/y, ({ context: { source, position, range } }) =>
+      new List([new Node(source[position + range - 1] === ':' ? 'end' : '')]), false),
   ])),
-  ns => new List([new Data(html('td', defrag(unwrap(ns))))]));
+  ns => new List([new Node(html('td', defrag(unwrap(ns))))]));
 
 const cell: CellParser = surround(
   /\|\s*(?=\S)/y,
@@ -59,13 +59,13 @@ const cell: CellParser = surround(
 
 const head: CellParser.HeadParser = fmap(
   cell,
-  ns => new List([new Data(html('th', defrag(unwrap(ns))))]));
+  ns => new List([new Node(html('th', defrag(unwrap(ns))))]));
 
 const data: CellParser.DataParser = fmap(
   cell,
-  ns => new List([new Data(html('td', defrag(unwrap(ns))))]));
+  ns => new List([new Node(html('td', defrag(unwrap(ns))))]));
 
-function format(rows: List<Data<HTMLTableRowElement>>): List<Data<HTMLTableRowElement>> {
+function format(rows: List<Node<HTMLTableRowElement>>): List<Node<HTMLTableRowElement>> {
   const aligns = rows.head!.value.className === 'invalid'
     ? []
     : duffReduce(rows.shift()!.value.children, (acc, el) => push(acc, [el.textContent!]), [] as string[]);

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

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

@@ -1,6 +1,6 @@
 import { UListParser } from '../block';
 import { Recursion } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_, ilistitem } from './ilist';
@@ -25,23 +25,23 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
-      ns => new List([new Data(html('li', { 'data-index': dataindex(ns) }, defrag(unwrap(fillFirstLine(ns)))))]))),
+      ns => new List([new Node(html('li', { 'data-index': dataindex(ns) }, defrag(unwrap(fillFirstLine(ns)))))]))),
   ])))),
-  ns => new List([new Data(format(html('ul', unwrap(ns))))]))));
+  ns => new List([new Node(format(html('ul', unwrap(ns))))]))));
 
 export const checkbox = focus(
   /\[[xX ]\](?=$|[ \n])/y,
   ({ context: { source, position } }) => new List([
-    new Data(html('span', { class: 'checkbox' }, source[position + 1].trimStart() ? '☑' : '☐')),
+    new Node(html('span', { class: 'checkbox' }, source[position + 1].trimStart() ? '☑' : '☐')),
   ]), false);
 
-export function fillFirstLine(nodes: List<Data<string | HTMLElement>>): List<Data<string | HTMLElement>> {
+export function fillFirstLine(nodes: List<Node<string | HTMLElement>>): List<Node<string | HTMLElement>> {
   const node = nodes.head?.value;
   if (typeof node !== 'object') return nodes;
   switch (node.tagName) {
     case 'UL':
     case 'OL':
-      nodes.unshift(new Data(html('br')));
+      nodes.unshift(new Node(html('br')));
   }
   return nodes;
 }

package/src/parser/block.ts

@@ -1,8 +1,9 @@
 import { MarkdownParser } from '../../markdown';
 import { Recursion, Command } from './context';
-import { List, Data } from '../combinator/data/parser';
+import { List, Node } from '../combinator/data/parser';
 import { union, reset, open, fallback, recover } from '../combinator';
 import { MAX_SEGMENT_SIZE } from './segment';
+import { header } from './header';
 import { emptyline } from './source';
 import { pagebreak } from './block/pagebreak';
 import { heading } from './block/heading';
@@ -43,7 +44,7 @@ export const block: BlockParser = reset(
   {
     resources: {
       // バックトラックのせいで文字数制限を受けないようにする。
-      clock: MAX_SEGMENT_SIZE * 5 + 1,
+      clock: MAX_SEGMENT_SIZE * 6 + 1,
       recursions: [
         10 || Recursion.block,
         20 || Recursion.blockquote,
@@ -73,6 +74,7 @@ export const block: BlockParser = reset(
           if (source[position + 1] === ' ') return dlist(input);
           break;
         case '-':
+          if (source.startsWith('---', position)) return header(input);
           if (source[position + 1] === ' ') return ulist(input) || ilist(input);
           break;
         case '+':
@@ -115,7 +117,7 @@ function error(parser: BlockParser): BlockParser {
     open(Command.Error, ({ context: { source, position } }) => { throw new Error(source.slice(position).split('\n', 1)[0]); }),
     parser),
     ({ context: { source, position, id } }, reason) => new List([
-      new Data(html('h1',
+      new Node(html('h1',
         {
           id: id !== '' ? `error:${rnd0Z(8)}` : undefined,
           class: 'error',
@@ -123,7 +125,7 @@ function error(parser: BlockParser): BlockParser {
         reason instanceof Error
           ? `${reason.name}: ${reason.message}`
           : `UnknownError: ${reason}`)),
-      new Data(html('pre',
+      new Node(html('pre',
         {
           class: 'error',
           translate: 'no',

package/src/parser/context.ts

@@ -1,3 +1,42 @@
+import { List, Node, Context as Ctx } from '../../src/combinator/data/parser';
+import { Dict } from 'spica/dict';
+
+export class Context extends Ctx {
+  constructor(
+    options: Partial<Context> = {},
+  ) {
+    super(options);
+    const {
+      buffer,
+      sequential,
+      header,
+      host,
+      url,
+      id,
+      caches,
+    } = options;
+    this.buffer = buffer ?? new List();
+    this.sequential = sequential ?? false;
+    this.header = header;
+    this.host = host;
+    this.url = url;
+    this.id = id;
+    this.caches = caches;
+  }
+  public buffer: List<Node<(string | HTMLElement)>>;
+  public sequential: boolean;
+  public readonly header?: boolean;
+  public readonly host?: URL;
+  public readonly url?: URL;
+  public readonly id?: string;
+  public readonly caches?: {
+    readonly code?: Dict<string, HTMLElement>;
+    readonly math?: Dict<string, HTMLElement>;
+    readonly media?: Dict<string, HTMLElement>;
+  };
+}
+export type Options = Partial<Context>;
+
 export const enum State {
   annotation = 1 << 7,
   reference = 1 << 6,

package/src/parser/header.test.ts

@@ -1,37 +1,37 @@
 import { header } from './header';
 import { input } from '../combinator/data/parser';
+import { Context } from './context';
 import { inspect } from '../debug.test';
 
 describe('Unit: parser/header', () => {
   describe('header', () => {
-    const parser = (source: string) => header(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = header;
 
     it('invalid', () => {
-      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('----\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>`], '']);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n---', new Context())), [['<pre class="invalid" translate="no">---\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n', new Context())), [['<pre class="invalid" translate="no">---\na: b\n</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---c', new Context())), [['<pre class="invalid" translate="no">---\na: b\n---c</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\nc', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\r \na: b\n---', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\na:\rb\n---', new Context())), [['<pre class="invalid" translate="no">---\na:\nb\n---</pre>'], '']);
+      //assert.deepStrictEqual(inspect(parser, input('---\na: b\r \n---', new Context())), [['<pre class="invalid" translate="no">---\na: b\n \n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\n\n---', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n \n---', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n-\n---', new Context())), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n----', new Context())), [['<pre class="invalid" translate="no">---\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('----\na: b\n---', new Context())), [['<pre class="invalid" translate="no">----\na: b\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`---\n${'a: b\n'.repeat(101)}---`, new Context())), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
     });
 
     it('basic', () => {
-      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']);
-      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, input('---\na: b\n---', new Context())), [['<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, input('---\na: b\n---\n', new Context())), [['<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, input('---\na: b\nC: D e\n---\n', new Context())), [['<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, input('--- \r\na: b \r\n--- \r\n \r\n \r\na', new Context())), [['<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, input('----\na: b\n----', new Context())), [['<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>'], '']);
     });
 
   });