securemark 0.299.4 → 0.300.0

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

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../block';
-import { List, Node, subinput } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, block, line, validate, fence, rewrite, clear, surround, open, convert, dup, lazy, fmap } from '../../../combinator';
+import { List, Node } from '../../../combinator/parser';
+import { union, inits, subsequence, some, scope, block, line, validate, fence, rewrite, surround, open, dup, lazy, fmap } from '../../../combinator';
 import { inline, medialink, media, lineshortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { unwrap, invalid } from '../../util';
@@ -10,6 +10,7 @@ import { splice } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import TableParser = ExtensionParser.TableParser;
+import GridTableParser = TableParser.GridTableParser;
 import RowParser = TableParser.RowParser;
 import AlignParser = TableParser.AlignParser;
 import CellParser = TableParser.CellParser;
@@ -17,17 +18,16 @@ import CellParser = TableParser.CellParser;
 const opener = /(~{3,})table(?:\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y;
 
 export const segment: TableParser.SegmentParser = block(
-  clear(fence(opener, 10000)));
+  fence(opener, false, 10000));
 
 export const segment_: TableParser.SegmentParser = block(
-  clear(fence(opener, 10000, false)), false);
+  fence(opener, false, 10000, false), false);
 
-export const table: TableParser = block(fmap(
-  fence(opener, 10000),
-  // Bug: Type mismatch between outer and inner.
-  (nodes: List<Node<string>>, context) => {
-    const [body, overflow, closer, opener, delim, type, param] = unwrap(nodes);
-    if (!closer || overflow || param.trimStart()) return new List([
+export const table: TableParser = block(inits([
+  fence(opener, true, 10000),
+  (_, output) => {
+    const [body, overflow, closer, opener, delim, type, param] = unwrap(output.pop()) as string[];
+    if (!closer || overflow || param.trimStart()) return output.append(
       new Node(html('pre', {
         class: 'invalid',
         translate: 'no',
@@ -37,27 +37,37 @@ export const table: TableParser = block(fmap(
           !closer ? `Missing the closing delimiter "${delim}"` :
             overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
               'Invalid argument'),
-      }, `${opener}${body}${overflow || closer}`))
-    ]);
+      }, `${opener}${body}${overflow || closer}`)));
     switch (type) {
-      case 'grid':
       case undefined:
-        return (parser(subinput(body, context)) ?? new List([new Node(html('table'))]))
-          .foldl(
-            (acc, { value }) => acc.push(new Node(define(value, { 'data-type': type }))) && acc,
-            new List());
+      case 'grid':
+        return [
+          (input, output) => {
+            input.scope.focus(body);
+            return output.context;
+          },
+          gridtable,
+          (input, output) => {
+            input.scope.unfocus();
+            !output.state && output.append(new Node(html('table')));
+            define(output.peek().last!.value, { 'data-type': type });
+            return output.context;
+          },
+        ];
       default:
-        return new List([
-          new Node(html('pre', {
-            class: 'invalid',
-            translate: 'no',
-            ...invalid('table', 'argument', 'Invalid table type'),
-          }, `${opener}${body}${closer}`))
-        ]);
+        return output.append(
+          new Node(html('pre',
+            {
+              class: 'invalid',
+              translate: 'no',
+              ...invalid('table', 'argument', 'Invalid table type'),
+            },
+            `${opener}${body}${closer}`)));
     }
-  }));
+  },
+]));
 
-const parser: TableParser = lazy(() => block(fmap(
+const gridtable: GridTableParser = lazy(() => block(fmap(
   some(union([row])),
   rows => new List([
     new Node(html('table', format([...unwrap(rows)])))
@@ -75,13 +85,14 @@ const row: RowParser = lazy(() => dup(fmap(
       emptyline,
     ])),
   ]),
-  ns => Array.isArray(ns.head?.value) ? ns : ns.unshift(new Node([[]])) && ns)));
+  ns => Array.isArray(ns.head?.value) ? ns : ns.unshift(new Node([[]])))));
 
 const alignment = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\r\n]*\r?\n)/y;
 
 const align: AlignParser = line(fmap(
   union([str(alignment)]),
-  ([{ value }]) => new List([new Node(value.split('/').map(s => s.split('')) as [string[], string[]?])])));
+  ([{ value }]) => new List([new Node(value.split('/').map(s => s.split('')) as [string[], string[]?])])),
+  false);
 
 const delimiter = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\r\n]*\r?\n)|[#:](?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \r\n])/y;
 
@@ -133,9 +144,10 @@ const dataline: CellParser.DatalineParser = line(
   rewrite(
     contentline,
     union([
-      validate(/!+ /y, convert(source => `:${source}`, data)),
-      convert(source => `: ${source}`, data),
-    ])));
+      validate(/!+ /y, scope(({ source }) => `:${source}`, data, true)),
+      scope(({ source }) => `: ${source}`, data, true),
+    ])),
+  false);
 
 function attributes(source: string): Record<string, string | undefined> {
   let [, rowspan = undefined, colspan = undefined, highlight = undefined, extension = undefined] =

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

@@ -1,38 +1,38 @@
 import { extension } from './extension';
 import { some } from '../../combinator';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
+import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/extension', () => {
   describe('extension', () => {
     const parser = some(extension);
 
     it('invalid', () => {
-      assert(!parser(input('', new Context())));
-      assert(!parser(input('\n', new Context())));
-      assert(!parser(input('~~~', new Context())));
-      assert(!parser(input('~~~\n', new Context())));
-      assert(!parser(input('~~~\n\n', new Context())));
-      assert(parser(input('~~~\na~~~', new Context())));
-      assert(!parser(input('~~~a', new Context())));
-      assert(!parser(input('~~~a ~~~\n~~~', new Context())));
-      assert(!parser(input('~~~a\n', new Context())));
-      assert(!parser(input('~~~a\n\n', new Context())));
-      assert(parser(input('~~~a\nb~~~', new Context())));
-      assert(!parser(input(' ~~~a\nb~~~', new Context())));
-      assert(!parser(input('$-name', new Context())));
-      assert(!parser(input('$-name-0', new Context())));
-      assert(!parser(input('$group-0', new Context())));
+      assert(!inspect(parser, input('')));
+      assert(!inspect(parser, input('\n')));
+      assert(!inspect(parser, input('~~~')));
+      assert(!inspect(parser, input('~~~\n')));
+      assert(!inspect(parser, input('~~~\n\n')));
+      assert(inspect(parser, input('~~~\na~~~')));
+      assert(!inspect(parser, input('~~~a')));
+      assert(!inspect(parser, input('~~~a ~~~\n~~~')));
+      assert(!inspect(parser, input('~~~a\n')));
+      assert(!inspect(parser, input('~~~a\n\n')));
+      assert(inspect(parser, input('~~~a\nb~~~')));
+      assert(!inspect(parser, input(' ~~~a\nb~~~')));
+      assert(!inspect(parser, input('$-name')));
+      assert(!inspect(parser, input('$-name-0')));
+      assert(!inspect(parser, input('$group-0')));
     });
 
     it('valid', () => {
-      assert(parser(input('~~~\n~~~', new Context())));
-      assert(parser(input('~~~\na\n~~~', new Context())));
-      assert(parser(input('~~~a\n~~~', new Context())));
-      assert(parser(input('~~~a\nb\n~~~', new Context())));
-      //assert(parser(input('$-0', new Context())));
-      //assert(parser(input('$-0\n', new Context())));
-      //assert(parser(input('$-0\n\n', new Context())));
+      assert(inspect(parser, input('~~~\n~~~')));
+      assert(inspect(parser, input('~~~\na\n~~~')));
+      assert(inspect(parser, input('~~~a\n~~~')));
+      assert(inspect(parser, input('~~~a\nb\n~~~')));
+      //assert(inspect(parser, input('$-0')));
+      //assert(inspect(parser, input('$-0\n')));
+      //assert(inspect(parser, input('$-0\n\n')));
     });
 
   });

package/src/parser/block/extension.ts

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../block';
-import { union } from '../../combinator';
+import { union, lazy } from '../../combinator';
 import { segment as seg_fig } from './extension/fig';
 import { figure, segment as seg_figure } from './extension/figure';
 import { table, segment as seg_table } from './extension/table';
@@ -15,7 +15,7 @@ export const segment: ExtensionParser.SegmentParser = union([
   seg_placeholder,
 ]);
 
-export const extension: ExtensionParser = union([
+export const extension: ExtensionParser = lazy(() => union([
   //figbase,
   //fig,
   figure,
@@ -24,4 +24,4 @@ export const extension: ExtensionParser = union([
   aside,
   example,
   placeholder,
-]);
+]));

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

@@ -1,7 +1,6 @@
 import { heading } from './heading';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
 import { some } from '../../combinator';
+import { input } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/heading', () => {
@@ -9,69 +8,69 @@ describe('Unit: parser/block/heading', () => {
     const parser = some(heading);
 
     it('invalid', () => {
-      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('#\n', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('#a\n', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('#a \n', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('#a\n#', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('#a\\\n#', 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())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('# a\nb', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('# *a\nb*', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('# a\n#b', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('####### a', new Context())), [['<h6 class="invalid" id="index::#######_a">####### a</h6>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(' # a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('#')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('#\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('#a\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('#a \n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('#a\n#')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('#a\\\n#')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('# ')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('#\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('# \n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('# a\nb')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('# *a\nb*')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('# a\n#b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('####### a')), [['<h6 class="invalid" id="index::#######_a">####### a</h6>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' # a')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('# a', new Context())), [['<h1 id="index::a">a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a ', new Context())), [['<h1 id="index::a">a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a b  c \n', new Context())), [['<h1 id="index::a_b_c">a b c</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a\n', new Context())), [['<h1 id="index::a">a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# *a*`b`${c}$', new Context())), [['<h1 id="index::a`b`${c}$"><em>a</em><code data-src="`b`">b</code><span class="math" translate="no" data-src="${c}$">${c}$</span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a\\', new Context())), [['<h1 id="index::a">a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a\\\n', new Context())), [['<h1 id="index::a">a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# \\', new Context())), [['<h1 id="index::\\">\\</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# \\ a', new Context())), [['<h1 id="index::a">a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('## \\', new Context())), [['<h2 id="index::\\">\\</h2>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# @a', new Context())), [['<h1 id="index::@a">@a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('## @a', new Context())), [['<h2 id="index::@a"><a class="account" href="/@a">@a</a></h2>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# http://host', new Context())), [['<h1 id="index::http://host">http://host</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('## http://host', new Context())), [['<h2 id="index::http://host"><a class="url" href="http://host" target="_blank">http://host</a></h2>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# !http://host', new Context())), [['<h1 id="index::!http://host">!http://host</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('## !http://host', new Context())), [['<h2 id="index::!http://host">!<a class="url" href="http://host" target="_blank">http://host</a></h2>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a((b))', new Context())), [['<h1 id="index::a((b))">a<span class="paren">(<span class="paren">(b)</span>)</span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('## a((b))', new Context())), [['<h2 id="index::a((b))">a<span class="paren">(<span class="paren">(b)</span>)</span></h2>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a[[b]]', new Context())), [['<h1 id="index::a[[b]]">a[[b]]</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('## a[[b]]', new Context())), [['<h2 id="index::a[[b]]">a[[b]]</h2>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('###### a', new Context())), [['<h6 id="index::a">a</h6>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a')), [['<h1 id="index::a">a</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a ')), [['<h1 id="index::a">a</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a b  c \n')), [['<h1 id="index::a_b_c">a b c</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a\n')), [['<h1 id="index::a">a</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# *a*`b`${c}$')), [['<h1 id="index::a`b`${c}$"><em>a</em><code data-src="`b`">b</code><span class="math" translate="no" data-src="${c}$">${c}$</span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a\\')), [['<h1 id="index::a">a</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a\\\n')), [['<h1 id="index::a">a</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# \\')), [['<h1 id="index::\\">\\</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# \\ a')), [['<h1 id="index::a">a</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('## \\')), [['<h2 id="index::\\">\\</h2>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# @a')), [['<h1 id="index::@a">@a</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('## @a')), [['<h2 id="index::@a"><a class="account" href="/@a">@a</a></h2>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# http://host')), [['<h1 id="index::http://host">http://host</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('## http://host')), [['<h2 id="index::http://host"><a class="url" href="http://host" target="_blank">http://host</a></h2>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# !http://host')), [['<h1 id="index::!http://host">!http://host</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('## !http://host')), [['<h2 id="index::!http://host">!<a class="url" href="http://host" target="_blank">http://host</a></h2>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a((b))')), [['<h1 id="index::a((b))">a<span class="paren">(<span class="paren">(b)</span>)</span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('## a((b))')), [['<h2 id="index::a((b))">a<span class="paren">(<span class="paren">(b)</span>)</span></h2>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a[[b]]')), [['<h1 id="index::a[[b]]">a[[b]]</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('## a[[b]]')), [['<h2 id="index::a[[b]]">a[[b]]</h2>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('###### a')), [['<h6 id="index::a">a</h6>'], '']);
     });
 
     it('indexer', () => {
-      assert.deepStrictEqual(inspect(parser, input('# [|a]', new Context())), [['<h1 id="index::[|a]"><span class="invalid">[|a]</span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a[|b]', new Context())), [['<h1 id="index::a[|b]">a<span class="invalid">[|b]</span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|b]', new Context())), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|b] ', new Context())), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|b]\\', new Context())), [['<h1 id="index::a_[|b]">a <span class="invalid">[|b]</span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|B]', new Context())), [['<h1 id="index::B">a<span class="indexer" data-index="B"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|b ]', new Context())), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|b  ]', new Context())), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|b c]', new Context())), [['<h1 id="index::b_c">a<span class="indexer" data-index="b_c"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|*b*\\`c\\`\\$\\{d\\}\\$]', new Context())), [['<h1 id="index::*b*`c`${d}$">a<span class="indexer" data-index="*b*`c`${d}$"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|@a]', new Context())), [['<h1 id="index::@a">a<span class="indexer" data-index="@a"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|http://host]', new Context())), [['<h1 id="index::http://host">a<span class="indexer" data-index="http://host"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|!http://host]', new Context())), [['<h1 id="index::!http://host">a<span class="indexer" data-index="!http://host"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|a\\(\\(b\\)\\)]', new Context())), [['<h1 id="index::a((b))">a<span class="indexer" data-index="a((b))"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|a\\[\\[b\\]\\]]', new Context())), [['<h1 id="index::a[[b]]">a<span class="indexer" data-index="a[[b]]"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a [|b] [|c]', new Context())), [['<h1 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a  [|b] \n', new Context())), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# a \\[|b]', new Context())), [['<h1 id="index::a_[|b]">a [|b]</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('# - [|b]', new Context())), [['<h1 id="index::b">-<span class="indexer" data-index="b"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('## a [|b] [|c]', new Context())), [['<h2 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h2>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# [|a]')), [['<h1 id="index::[|a]"><span class="invalid">[|a]</span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a[|b]')), [['<h1 id="index::a[|b]">a<span class="invalid">[|b]</span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|b]')), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|b] ')), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|b]\\')), [['<h1 id="index::a_[|b]">a <span class="invalid">[|b]</span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|B]')), [['<h1 id="index::B">a<span class="indexer" data-index="B"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|b ]')), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|b  ]')), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|b c]')), [['<h1 id="index::b_c">a<span class="indexer" data-index="b_c"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|*b*\\`c\\`\\$\\{d\\}\\$]')), [['<h1 id="index::*b*`c`${d}$">a<span class="indexer" data-index="*b*`c`${d}$"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|@a]')), [['<h1 id="index::@a">a<span class="indexer" data-index="@a"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|http://host]')), [['<h1 id="index::http://host">a<span class="indexer" data-index="http://host"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|!http://host]')), [['<h1 id="index::!http://host">a<span class="indexer" data-index="!http://host"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|a\\(\\(b\\)\\)]')), [['<h1 id="index::a((b))">a<span class="indexer" data-index="a((b))"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|a\\[\\[b\\]\\]]')), [['<h1 id="index::a[[b]]">a<span class="indexer" data-index="a[[b]]"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a [|b] [|c]')), [['<h1 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a  [|b] \n')), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# a \\[|b]')), [['<h1 id="index::a_[|b]">a [|b]</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('# - [|b]')), [['<h1 id="index::b">-<span class="indexer" data-index="b"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('## a [|b] [|c]')), [['<h2 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h2>'], '']);
     });
 
   });

package/src/parser/block/heading.ts

@@ -1,6 +1,6 @@
 import { HeadingParser } from '../block';
 import { Segment, State } from '../context';
-import { List, Node } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/parser';
 import { union, some, state, block, line, focus, rewrite, open, fmap, firstline } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { str, strs } from '../source';
@@ -9,39 +9,40 @@ import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(focus(
-  /#+ +\S[^\r\n]*(?:\r?\n#+(?=$|[ \r\n])[^\r\n]*)*(?:$|\r?\n)/y,
-  input => {
-    const context = input;
-    const { source, range } = context;
+  /#+ +\S[^\r\n]*(?:\r?\n#+(?=$|[ \r\n])[^\r\n]*)*(?:$|\r?\n(?=[^\S\r\n]*(?:$|\r?\n)))/y,
+  (input, output) => {
+    const { source, range } = input;
     const acc = new List<Node<string>>();
-    for (const len = context.position + range; context.position < len;) {
-      const line = firstline(source, context.position);
+    for (const len = input.position + range; input.position < len;) {
+      const line = firstline(source, input.position);
       acc.push(new Node(line));
-      context.position += line.length;
+      input.position += line.length;
     }
-    return acc;
+    return output.import(acc);
   }, false), true, Segment.heading);
 
 export const heading: HeadingParser = block(rewrite(segment,
   // その他の表示制御は各所のCSSで行う。
   state(State.annotation | State.reference | State.index | State.label | State.link,
-  line(indexee(fmap(union([
+  indexee(fmap(union([
     open(
       strs('#', 2),
-      visualize(trimBlank(some(union([indexer, inline])))), true),
+      line(visualize(trimBlank(some(union([indexer, inline])))), true)),
     open(
       str('#'),
       state(State.linkers,
-      visualize(trimBlank(some(union([indexer, inline]))))), true),
+      line(visualize(trimBlank(some(union([indexer, inline])))))), true),
   ]),
-  (nodes, context) => {
+  (nodes, { source, position, range }) => {
     const [h, ...ns] = unwrap(nodes) as [string, ...(HTMLElement | string)[]];
     return new List([
       h.length <= 6
         ? new Node(html(`h${h.length as 1}`, { 'data-index': dataindex(nodes) }, defrag(ns)))
-        : new Node(html(`h6`, {
-          class: 'invalid',
-          ...invalid('heading', 'syntax', 'Heading level must be up to 6'),
-        }, context.source.slice(context.position - context.range, context.position)))
+        : new Node(html(`h6`,
+            {
+              class: 'invalid',
+              ...invalid('heading', 'syntax', 'Heading level must be up to 6'),
+            },
+            source.slice(position - range, position)))
     ]);
-  }))))));
+  })))));

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

@@ -1,19 +1,19 @@
 import { ilist } from './ilist';
 import { some } from '../../combinator';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
+import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/ilist', () => {
   describe('ilist', () => {
     const parser = some(ilist);
 
     it('single', () => {
-      assert(!parser(input('-', new Context())));
-      assert(!parser(input('+', new Context())));
-      assert(!parser(input('*', new Context())));
-      assert(parser(input('- ', new Context())));
-      assert(parser(input('+ ', new Context())));
-      assert(parser(input('* ', new Context())));
+      assert(!inspect(parser, input('-')));
+      assert(!inspect(parser, input('+')));
+      assert(!inspect(parser, input('*')));
+      assert(inspect(parser, input('- ')));
+      assert(inspect(parser, input('+ ')));
+      assert(inspect(parser, input('* ')));
     });
 
   });

package/src/parser/block/ilist.ts

@@ -1,7 +1,6 @@
 import { IListParser } from '../block';
-import { Parser } from '../../combinator/data/parser';
 import { Recursion } from '../context';
-import { List, Node } from '../../combinator/data/parser';
+import { Parser, List, Node } from '../../combinator/parser';
 import { union, inits, some, recursion, block, line, validate, indent, rewrite, open, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, fillFirstLine } from './ulist';
 import { olist_ } from './olist';
@@ -17,10 +16,10 @@ export const ilist: IListParser = lazy(() => block(validate(
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(
   /[-+*](?:$|[ \r\n])/y,
-  recursion(Recursion.listitem, some(union([
+  recursion(Recursion.block, some(union([
     fmap(fallback(
       inits([
-        line(open(/[-+*](?:$|[ \r\n])/y, visualize(trimBlank(some(inline))), true)),
+        open(/[-+*](?:$|[ \r\n])/y, line(visualize(trimBlank(some(inline)))), true),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
@@ -34,11 +33,14 @@ export const ilist_: IListParser = lazy(() => block(fmap(validate(
   ]))));
 
 export const ilistitem = rewrite(
-  inits([contentline, indent<Parser<string>>(({ source }) => new List([new Node(source)]))]),
-  ({ source }) => new List([
+  inits([
+    contentline,
+    indent<Parser<string>>(({ source }, output) => output.append(new Node(source))),
+  ]),
+  ({ source }, output) => output.import(new List([
     new Node(''),
     new Node(html('span', {
       class: 'invalid',
       ...invalid('list', 'syntax', 'Fix the indent or the head of the list item'),
     }, source.replace(/\r?\n/, '')))
-  ]));
+  ])));

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

@@ -1,7 +1,6 @@
 import { mathblock } from './mathblock';
 import { some } from '../../combinator';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/mathblock', () => {
@@ -9,39 +8,39 @@ describe('Unit: parser/block/mathblock', () => {
     const parser = some(mathblock);
 
     it('invalid', () => {
-      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('$$\n', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$$\na', new Context())), [['<pre class="invalid" translate="no">$$\na</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\na$$', new Context())), [['<pre class="invalid" translate="no">$$\na$$</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$b', new Context())), [['<pre class="invalid" translate="no">$$\na\n$$b</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$\nb', new Context())), [['<pre class="invalid" translate="no">$$\na\n$$\nb</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$$\n\n\n$$$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$$ $$\n$$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$$lang\n$$', new Context())), [['<pre class="invalid" translate="no">$$lang\n$$</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$ param\n$$', new Context())), [['<pre class="invalid" translate="no">$$ param\n$$</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n$$\n$$', new Context())), [['<pre class="invalid" translate="no">$$\n$$\n$$</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n$$$', new Context())), [['<pre class="invalid" translate="no">$$\n$$$</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$$\n$$', new Context())), [['<pre class="invalid" translate="no">$$$\n$$</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$$\n$$$', new Context())), [['<pre class="invalid" translate="no">$$$\n$$$</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(' $$\n$$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(301)}$$`, new Context()), '>'), [['<pre class="invalid" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$$\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$$\na')), [['<pre class="invalid" translate="no">$$\na</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\na$$')), [['<pre class="invalid" translate="no">$$\na$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$b')), [['<pre class="invalid" translate="no">$$\na\n$$b</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$\nb')), [['<pre class="invalid" translate="no">$$\na\n$$\nb</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$$\n\n\n$$$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$$ $$\n$$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$$lang\n$$')), [['<pre class="invalid" translate="no">$$lang\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$ param\n$$')), [['<pre class="invalid" translate="no">$$ param\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$$\n$$')), [['<pre class="invalid" translate="no">$$\n$$\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$$$')), [['<pre class="invalid" translate="no">$$\n$$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$$\n$$')), [['<pre class="invalid" translate="no">$$$\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$$\n$$$')), [['<pre class="invalid" translate="no">$$$\n$$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' $$\n$$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(301)}$$`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('$$\n$$', new Context())), [['<div class="math" translate="no">$$\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n\n$$', new Context())), [['<div class="math" translate="no">$$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$', new Context())), [['<div class="math" translate="no">$$\na\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$\n', new Context())), [['<div class="math" translate="no">$$\na\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\na\nb\n$$', new Context())), [['<div class="math" translate="no">$$\na\nb\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n\\\n$$', new Context())), [['<div class="math" translate="no">$$\n\\\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n$\n$$', new Context())), [['<div class="math" translate="no">$$\n$\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n$\n\n$$', new Context())), [['<div class="math" translate="no">$$\n$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n$$\n\n$$', new Context())), [['<div class="math" translate="no">$$\n$$</div>'], '\n$$']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n$$', new Context())), [['<div class="math" translate="no">$$\n$$$\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n\n$$', new Context())), [['<div class="math" translate="no">$$\n$$$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(300)}$$`, new Context()), '>'), [['<div class="math" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$$')), [['<div class="math" translate="no">$$\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n\n$$')), [['<div class="math" translate="no">$$\n\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$')), [['<div class="math" translate="no">$$\na\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\na\n$$\n')), [['<div class="math" translate="no">$$\na\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\na\nb\n$$')), [['<div class="math" translate="no">$$\na\nb\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n\\\n$$')), [['<div class="math" translate="no">$$\n\\\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$\n$$')), [['<div class="math" translate="no">$$\n$\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$\n\n$$')), [['<div class="math" translate="no">$$\n$\n\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$$\n\n$$')), [['<div class="math" translate="no">$$\n$$</div>'], '\n$$']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n$$')), [['<div class="math" translate="no">$$\n$$$\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n\n$$')), [['<div class="math" translate="no">$$\n$$$\n\n$$</div>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(300)}$$`), '>'), [['<div class="math" translate="no">'], '']);
     });
 
   });