securemark 0.299.3 → 0.300.0

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

@@ -1,7 +1,6 @@
 import { sidefence } from './sidefence';
 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/sidefence', () => {
@@ -9,58 +8,52 @@ describe('Unit: parser/block/sidefence', () => {
     const parser = some(sidefence);
 
     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('|a', 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('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|a')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|\na')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|\n| a')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' | ')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('||')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('| ', new Context())), [['<blockquote class="invalid"></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| \\', new Context())), [['<blockquote class="invalid"><pre>\\</pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| \\\n', new Context())), [['<blockquote class="invalid"><pre>\\</pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a', new Context())), [['<blockquote class="invalid"><pre>a</pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n', new Context())), [['<blockquote class="invalid"><pre>a</pre></blockquote>'], '']);
-      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\n|', new Context())), [['<blockquote class="invalid"><pre>a<br></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n>>1', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('| a\n| b ', new Context())), [['<blockquote class="invalid"><pre>a<br>b </pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|\n', new Context())), [['<blockquote class="invalid"><pre>a<br></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|\nb', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|\n b ', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|\n|', new Context())), [['<blockquote class="invalid"><pre>a<br><br></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|\n>>1', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|\n| b ', new Context())), [['<blockquote class="invalid"><pre>a<br><br>b </pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\\\nb', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('|  a ', new Context())), [['<blockquote class="invalid"><pre> a </pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| \na', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('|\na', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('|\n| a', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('| http://host', new Context())), [['<blockquote class="invalid"><pre><a class="url" href="http://host" target="_blank">http://host</a></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| http://host)', new Context())), [['<blockquote class="invalid"><pre><a class="url" href="http://host)" target="_blank">http://host)</a></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| !http://host', new Context())), [['<blockquote class="invalid"><pre>!<a class="url" href="http://host" target="_blank">http://host</a></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| !http://host)', new Context())), [['<blockquote class="invalid"><pre>!<a class="url" href="http://host)" target="_blank">http://host)</a></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| #a', new Context())), [['<blockquote class="invalid"><pre><a class="hashtag" href="/hashtags/a">#a</a></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| @a#b', new Context())), [['<blockquote class="invalid"><pre><a class="channel" href="/@a?ch=b">@a#b</a></pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| >>1\n| | b', new Context())), [['<blockquote class="invalid"><pre><a class="anchor" href="?at=1">&gt;&gt;1</a><br>| b</pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| >>1\n| | b\n| c', new Context())), [['<blockquote class="invalid"><pre><a class="anchor" href="?at=1">&gt;&gt;1</a><br>| b<br>c</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| ')), [['<blockquote class="invalid"></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| \\')), [['<blockquote class="invalid"><pre>\\</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| \\\n')), [['<blockquote class="invalid"><pre>\\</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a')), [['<blockquote class="invalid"><pre>a</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n')), [['<blockquote class="invalid"><pre>a</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\nb')), [['<blockquote class="invalid"><pre>a</pre><pre class="invalid">b</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n b \n')), [['<blockquote class="invalid"><pre>a</pre><pre class="invalid"> b</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n|')), [['<blockquote class="invalid"><pre>a<br></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n||1')), [['<blockquote class="invalid"><pre>a</pre><pre class="invalid">||1</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n| b ')), [['<blockquote class="invalid"><pre>a<br>b </pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n|\n')), [['<blockquote class="invalid"><pre>a<br></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|  a ')), [['<blockquote class="invalid"><pre> a </pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| \na')), [['<blockquote class="invalid"><pre class="invalid">a</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| http://host')), [['<blockquote class="invalid"><pre><a class="url" href="http://host" target="_blank">http://host</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| http://host)')), [['<blockquote class="invalid"><pre><a class="url" href="http://host)" target="_blank">http://host)</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| !http://host')), [['<blockquote class="invalid"><pre>!<a class="url" href="http://host" target="_blank">http://host</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| !http://host)')), [['<blockquote class="invalid"><pre>!<a class="url" href="http://host)" target="_blank">http://host)</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| #a')), [['<blockquote class="invalid"><pre><a class="hashtag" href="/hashtags/a">#a</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| @a#b')), [['<blockquote class="invalid"><pre><a class="channel" href="/@a?ch=b">@a#b</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| ||1\n| | b')), [['<blockquote class="invalid"><pre>||1<br>| b</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| ||1\n| | b\n| c')), [['<blockquote class="invalid"><pre>||1<br>| b<br>c</pre></blockquote>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('| a\n||', new Context())), [['<blockquote class="invalid"><pre>a</pre><blockquote></blockquote></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|| b\n| c', new Context())), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b</pre></blockquote><pre>c</pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|| b\n|| c', new Context())), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b<br>c</pre></blockquote></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('| a\n|| b\n||| c', new Context())), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b</pre><blockquote><pre>c</pre></blockquote></blockquote></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('|| a', new Context())), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('|| a\n|', new Context())), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('|| a\n| b', new Context())), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote><pre>b</pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('|| a\n||| b\n| c', new Context())), [['<blockquote class="invalid"><blockquote><pre>a</pre><blockquote><pre>b</pre></blockquote></blockquote><pre>c</pre></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('|| a\n| b\n||| c', new Context())), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote><pre>b</pre><blockquote><blockquote><pre>c</pre></blockquote></blockquote></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('||| a\n|| b\n| c', new Context())), [['<blockquote class="invalid"><blockquote><blockquote><pre>a</pre></blockquote><pre>b</pre></blockquote><pre>c</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n||')), [['<blockquote class="invalid"><pre>a</pre><blockquote></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n|| b\n| c')), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b</pre></blockquote><pre>c</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n|| b\n|| c')), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b<br>c</pre></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('| a\n|| b\n||| c')), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b</pre><blockquote><pre>c</pre></blockquote></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|| a')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|| a\n|')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|| a\n| b')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote><pre>b</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|| a\n||| b\n| c')), [['<blockquote class="invalid"><blockquote><pre>a</pre><blockquote><pre>b</pre></blockquote></blockquote><pre>c</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|| a\n| b\n||| c')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote><pre>b</pre><blockquote><blockquote><pre>c</pre></blockquote></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('||| a\n|| b\n| c')), [['<blockquote class="invalid"><blockquote><blockquote><pre>a</pre></blockquote><pre>b</pre></blockquote><pre>c</pre></blockquote>'], '']);
     });
 
   });

package/src/parser/block/sidefence.ts

@@ -1,33 +1,39 @@
 import { SidefenceParser } from '../block';
-import { Recursion } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, block, focus, rewrite, open, convert, lazy, fmap } from '../../combinator';
+import { Input, Recursion } from '../context';
+import { List, Node } from '../../combinator/parser';
+import { union, some, force, recursion, scope, block, line, validate, rewrite, open, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { unwrap, invalid } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
-  /\|+ [^\r\n]*(?:\r?\n\|+(?=$|[ \r\n])[^\r\n]*)*(?:$|\r?\n)/y,
-  union([source])),
+export const sidefence: SidefenceParser = lazy(() => validate(/\|+ /y, block(fmap(
+  union([source]),
   ([{ value }]) => new List([
     new Node(define(value, {
       class: 'invalid',
       ...invalid('sidefence', 'syntax', 'Reserved syntax'),
     })),
-  ]))));
+  ])))));
 
 const opener = /(?=\|\|+(?:$|[ \r\n]))/y;
 const indent = open(opener, some(contentline, /\|(?:$|[ \r\n])/y));
-const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?: |(?=\|*(?:$|[ \r\n])))|\r?\n$/g, '');
+const unindent = ({ source }: Input) => source.replace(/(?<=^|\n)\|(?: |(?=\|*(?:$|[ \r\n])))|\r?\n$/g, '');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
   recursion(Recursion.block, some(union([
     rewrite(
       indent,
-      convert(unindent, source)),
+      scope(unindent, source, false)),
     rewrite(
-      some(contentline, opener),
-      convert(unindent, fmap(autolink, ns => new List([new Node(html('pre', defrag(unwrap(ns))))])))),
+      some(validate(/\|(?:$|[ \r\n])/y, contentline), opener),
+      scope(unindent, force(fmap(autolink, ns => new List([new Node(html('pre', defrag(unwrap(ns))))]))), false)),
+    line(({source}, output) => output.append(
+      new Node(html('pre',
+        {
+          class: 'invalid',
+          ...invalid('sidefence', 'syntax', 'Missing the start symbol "|"'),
+        },
+        source.trimEnd())))),
   ]))),
   ns => new List([new Node(html('blockquote', unwrap(ns)))])));

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

@@ -1,7 +1,6 @@
 import { table } from './table';
 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/table', () => {
@@ -9,62 +8,62 @@ describe('Unit: parser/block/table', () => {
     const parser = some(table);
 
     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('||', 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|\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);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('||')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|||')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|\n|')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|\n|\n|')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h\n|')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h\n|b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h\n|-\nb')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h\n|-\n |b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('|h\n |-\n|b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' |h\n|-\n|b')), undefined);
     });
 
     it('valid', () => {
-      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><span class="paren">(<span class="paren">(</span></span></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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|\n|-\n|')), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('||\n|-|\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|||\n|-|-|\n|||')), [['<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|')), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|`|`|\n|-\n|')), [['<table><thead><tr><th><code data-src="`|`">|</code></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|((|\n|-\n|')), [['<table><thead><tr><th><span class="paren">(<span class="paren">(</span></span></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|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, input('|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, input('|a|\n|-|\n|1|')), [['<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')), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('||\n|-\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('||\n|-\n||\\')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('||\n|-\n||\\ ')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('||\n|-\n||\\\n')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('||\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, input('|| \n|- \n|| ')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|| \n|-| \n|| ')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
     });
 
     it('align', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|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, input('|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, input('|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, input('|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, input('|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, input('|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, input('|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, input('|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, input('|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, input('|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>'], '']);
     });
 
     it('trim', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('|  h  \n|- \n|  b  ')), [['<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  | ')), [['<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  \\')), [['<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  \\ | ')), [['<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, Node } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/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';
@@ -30,20 +30,21 @@ 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 Node(html('tr', unwrap(ns)))])),
-  rewrite(contentline, ({ source }) => new List([
+  rewrite(contentline, ({ source }, output) => output.append(
     new Node(html('tr', {
       class: 'invalid',
-      ...invalid('table-row', 'syntax', 'Missing the start symbol of the table row'),
-    }, [html('td', source.replace(/\r?\n/, ''))]))
-  ])));
+      ...invalid('table', 'syntax', 'Missing the start symbol "|"'),
+    }, [html('td', source.replace(/\r?\n/, ''))])))));
 
 const align: AlignParser = fmap(open(
   '|',
   union([
-    focus(/:-+:?/y, ({ source, position, range }) =>
-      new List([new Node(source[position + range - 1] === ':' ? 'center' : 'start')]), false),
-    focus(/-+:?/y, ({ source, position, range }) =>
-      new List([new Node(source[position + range - 1] === ':' ? 'end' : '')]), false),
+    focus(/:-+:?/y, ({ source, position, range }, output) => output.append(
+      new Node(source[position + range - 1] === ':' ? 'center' : 'start')),
+      false),
+    focus(/-+:?/y, ({ source, position, range }, output) => output.append(
+      new Node(source[position + range - 1] === ':' ? 'end' : '')),
+      false),
   ])),
   ns => new List([new Node(html('td', defrag(unwrap(ns))))]));
 

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

@@ -1,7 +1,6 @@
 import { ulist } from './ulist';
 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/ulist', () => {
@@ -9,77 +8,77 @@ describe('Unit: parser/block/ulist', () => {
     const parser = some(ulist);
 
     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('--', 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);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('--')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-0')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-a')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-[]')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-[ ]')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-[x]')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('-\n- a')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' - ')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('+')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('*')), undefined);
     });
 
     it('single', () => {
       // pending
-      assert.deepStrictEqual(inspect(parser, input('- ', new Context())), [['<ul><li></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- ')), [['<ul><li></li></ul>'], '']);
       // filled
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- \\')), [['<ul><li id="index::\\">\\</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- \\\n')), [['<ul><li id="index::\\">\\</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- -')), [['<ul><li id="index::-">-</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- -\n')), [['<ul><li id="index::-">-</li></ul>'], '']);
     });
 
     it('multiple', () => {
       // pending
-      assert.deepStrictEqual(inspect(parser, input('- \n-', new Context())), [['<ul><li></li><li></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- \n-')), [['<ul><li></li><li></li></ul>'], '']);
       // filled
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 1\n- 2')), [['<ul><li id="index::1">1</li><li id="index::2">2</li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 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>'], '']);
       // invalid
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- \n+')), [['<ul><li></li><li id="index::+"><span class="invalid">+</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- \n0')), [['<ul><li></li><li id="index::0"><span class="invalid">0</span></li></ul>'], '']);
     });
 
     it('nest', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- \n -')), [['<ul><li><br><ul><li></li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 1\n - 2')), [['<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')), [['<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')), [['<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')), [['<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')), [['<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+')), [['<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')), [['<ul><li id="index::1">1<ul class="invalid"><li>2</li></ul></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 1\n 0')), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 1\n 0.')), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 1\n 0. ')), [['<ul><li id="index::1">1<ol><li></li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 1\n 0. 2')), [['<ul><li id="index::1">1<ol><li id="index::2">2</li></ol></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- a [#b]')), [['<ul><li id="index::a_b">a <a class="index" href="#index::b">b</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- 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, input('- !http://host')), [['<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, 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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- [ ]')), [['<ul class="checklist"><li><span class="checkbox">☐</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- [x]')), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- [X]')), [['<ul class="checklist"><li><span class="checkbox">☑</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- [X] 1')), [['<ul class="checklist"><li id="index::1"><span class="checkbox">☑</span>1</li></ul>'], '']);
     });
 
     it('indexer', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- [|a]')), [['<ul><li id="index::[|a]"><span class="invalid">[|a]</span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- a [|]')), [['<ul><li>a<span class="indexer" data-index=""></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- a [|b]')), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- - [|b]')), [['<ul><li id="index::b">-<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('- [ ] [|a]')), [['<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]')), [['<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]')), [['<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]')), [['<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, Node } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/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';
@@ -13,15 +13,16 @@ export const ulist: UListParser = lazy(() => block(validate(
   '- ',
   ulist_)));
 
+// TODO: リストマーカーの直書き
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
   /-(?=$|[ \r\n])/y,
-  recursion(Recursion.listitem, some(union([
+  recursion(Recursion.block, some(union([
     indexee(fmap(fallback(
       inits([
-        line(open(/-(?:$|[ \r\n])/y, subsequence([
+        open(/-(?=$|[ \r\n]) ?/y, subsequence([
           checkbox,
-          visualize(trimBlank(some(union([indexer, inline])))),
-        ]), true)),
+          line(visualize(trimBlank(some(union([indexer, inline]))))),
+        ]), true),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
@@ -31,9 +32,9 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
 
 export const checkbox = focus(
   /\[[xX ]\](?=$|[ \r\n])/y,
-  ({ source, position }) => new List([
-    new Node(html('span', { class: 'checkbox' }, source[position + 1].trimStart() ? '☑' : '☐')),
-  ]), false);
+  ({ source, position }, output) => output.append(
+    new Node(html('span', { class: 'checkbox' }, source[position + 1].trimStart() ? '☑' : '☐'))),
+  false);
 
 export function fillFirstLine(nodes: List<Node<string | HTMLElement>>): List<Node<string | HTMLElement>> {
   const node = nodes.head?.value;