securemark 0.299.4 → 0.300.0

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

@@ -1,7 +1,6 @@
 import { dlist } from './dlist';
 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/dlist', () => {
@@ -9,70 +8,70 @@ describe('Unit: parser/block/dlist', () => {
     const parser = some(dlist);
 
     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('~ \n', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~ \na', 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('~a:b', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~a\n:b', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~a\n: b', 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('~\n:\n', new Context())), undefined);
-      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())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~\na', 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('~ \n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~ \na')), 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('~a:b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~a\n:b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~a\n: b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~\n:')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~\n:\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~\n~\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~\n~\n:')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~\n:\n:')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~\na')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ~ ')), undefined);
     });
 
     it('single', () => {
-      assert.deepStrictEqual(inspect(parser, input('~ a', new Context())), [['<dl><dt id="index::a">a</dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ \\', new Context())), [['<dl><dt id="index::\\">\\</dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ \\ a', new Context())), [['<dl><dt id="index::a">a</dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\nb', new Context())), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\nb\n', new Context())), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\nb\nc', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\nb\n\\\nc', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br>\\<br>c</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n~', new Context())), [['<dl><dt id="index::a">a</dt><dd>~</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n~b', new Context())), [['<dl><dt id="index::a">a</dt><dd>~b</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n~ b', new Context())), [['<dl><dt id="index::a">a</dt><dt id="index::b">b</dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n:', new Context())), [['<dl><dt id="index::a">a</dt><dd>:</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: ', new Context())), [['<dl><dt id="index::a">a</dt><dd>:</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: \n', new Context())), [['<dl><dt id="index::a">a</dt><dd>:</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: \\', new Context())), [['<dl><dt id="index::a">a</dt><dd>\\</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n:b', new Context())), [['<dl><dt id="index::a">a</dt><dd>:b</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b', new Context())), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n', new Context())), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\nc', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n\\\nc', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br>\\<br>c</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a~ b', new Context())), [['<dl><dt id="index::a~_b">a~ b</dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a: b', new Context())), [['<dl><dt id="index::a:_b">a: b</dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a \n: b\nc ', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a \n: b\n c ', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br> c</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a')), [['<dl><dt id="index::a">a</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ \\')), [['<dl><dt id="index::\\">\\</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ \\ a')), [['<dl><dt id="index::a">a</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\nb')), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\nb\n')), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\nb\nc')), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\nb\n\\\nc')), [['<dl><dt id="index::a">a</dt><dd>b<br>\\<br>c</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n~')), [['<dl><dt id="index::a">a</dt><dd>~</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n~b')), [['<dl><dt id="index::a">a</dt><dd>~b</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n~ b')), [['<dl><dt id="index::a">a</dt><dt id="index::b">b</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n:')), [['<dl><dt id="index::a">a</dt><dd>:</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: ')), [['<dl><dt id="index::a">a</dt><dd>:</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: \n')), [['<dl><dt id="index::a">a</dt><dd>:</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: \\')), [['<dl><dt id="index::a">a</dt><dd>\\</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n:b')), [['<dl><dt id="index::a">a</dt><dd>:b</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b')), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n')), [['<dl><dt id="index::a">a</dt><dd>b</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\nc')), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n\\\nc')), [['<dl><dt id="index::a">a</dt><dd>b<br>\\<br>c</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a~ b')), [['<dl><dt id="index::a~_b">a~ b</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a: b')), [['<dl><dt id="index::a:_b">a: b</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a \n: b\nc ')), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a \n: b\n c ')), [['<dl><dt id="index::a">a</dt><dd>b<br> c</dd></dl>'], '']);
     });
 
     it('multiple', () => {
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n~ c\n: d', new Context())), [['<dl><dt id="index::a">a</dt><dd>b</dd><dt id="index::c">c</dt><dd>d</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n  b\nc\n  d', new Context())), [['<dl><dt id="index::a">a</dt><dd>  b<br>c<br>  d</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\nc\n: d', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd><dd>d</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\nc\n~ d\n: e', new Context())), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd><dt id="index::d">d</dt><dd>e</dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n~ c\n: d\n~ e\n: f', new Context())), [['<dl><dt id="index::a">a</dt><dd>b</dd><dt id="index::c">c</dt><dd>d</dd><dt id="index::e">e</dt><dd>f</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n~ c\n: d')), [['<dl><dt id="index::a">a</dt><dd>b</dd><dt id="index::c">c</dt><dd>d</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n  b\nc\n  d')), [['<dl><dt id="index::a">a</dt><dd>  b<br>c<br>  d</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\nc\n: d')), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd><dd>d</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\nc\n~ d\n: e')), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd><dt id="index::d">d</dt><dd>e</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a\n: b\n~ c\n: d\n~ e\n: f')), [['<dl><dt id="index::a">a</dt><dd>b</dd><dt id="index::c">c</dt><dd>d</dd><dt id="index::e">e</dt><dd>f</dd></dl>'], '']);
     });
 
     it('indexer', () => {
-      assert.deepStrictEqual(inspect(parser, input('~ a [|b]', new Context())), [['<dl><dt id="index::b">a<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ a [|b]\\', new Context())), [['<dl><dt id="index::a_[|b]">a <span class="invalid">[|b]</span></dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ - [|b]', new Context())), [['<dl><dt id="index::b">-<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ *A*', new Context())), [['<dl><dt id="index::A"><em>A</em></dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ `A`', new Context())), [['<dl><dt id="index::`A`"><code data-src="`A`">A</code></dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~ ${A}$', new Context())), [['<dl><dt id="index::${A}$"><span class="math" translate="no" data-src="${A}$">${A}$</span></dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a [|b]')), [['<dl><dt id="index::b">a<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ a [|b]\\')), [['<dl><dt id="index::a_[|b]">a <span class="invalid">[|b]</span></dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ - [|b]')), [['<dl><dt id="index::b">-<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ *A*')), [['<dl><dt id="index::A"><em>A</em></dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ `A`')), [['<dl><dt id="index::`A`"><code data-src="`A`">A</code></dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~ ${A}$')), [['<dl><dt id="index::${A}$"><span class="math" translate="no" data-src="${A}$">${A}$</span></dt><dd></dd></dl>'], '']);
     });
 
   });

package/src/parser/block/dlist.ts

@@ -1,6 +1,6 @@
 import { DListParser } from '../block';
 import { State } from '../context';
-import { List, Node } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/parser';
 import { union, inits, some, state, block, line, validate, rewrite, open, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { anyline } from '../source';
@@ -17,11 +17,11 @@ export const dlist: DListParser = lazy(() => block(fmap(validate(
   ]))),
   ns => new List([new Node(html('dl', unwrap(fillTrailingDescription(ns))))]))));
 
-const term: DListParser.TermParser = line(indexee(fmap(open(
+const term: DListParser.TermParser = indexee(fmap(open(
   /~ +(?=\S)/y,
-  visualize(trimBlank(some(union([indexer, inline])))),
+  line(visualize(trimBlank(some(union([indexer, inline]))))),
   true),
-  ns => new List([new Node(html('dt', { 'data-index': dataindex(ns) }, defrag(unwrap(ns))))]))));
+  ns => new List([new Node(html('dt', { 'data-index': dataindex(ns) }, defrag(unwrap(ns))))])));
 
 const desc: DListParser.DescriptionParser = block(fmap(open(
   /: +(?=\S)|/y,
@@ -34,6 +34,6 @@ const desc: DListParser.DescriptionParser = block(fmap(open(
 
 function fillTrailingDescription(nodes: List<Node<HTMLElement>>): List<Node<HTMLElement>> {
   return nodes.last?.value.tagName === 'DT'
-    ? nodes.push(new Node(html('dd'))) && nodes
+    ? nodes.push(new Node(html('dd')))
     : nodes;
 }

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

@@ -1,7 +1,6 @@
 import { aside } from './aside';
 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/aside', () => {
@@ -9,16 +8,16 @@ describe('Unit: parser/block/extension/aside', () => {
     const parser = some(aside);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~~aside\n~~~', new Context())), [['<pre class="invalid" translate="no">~~~aside\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~aside\n# \n~~~', new Context())), [['<pre class="invalid" translate="no">~~~aside\n# \n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~aside a\n# 0\n~~~', new Context())), [['<pre class="invalid" translate="no">~~~aside a\n# 0\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~aside\n# 0${'\n'.repeat(301)}~~~`, new Context()), '>'), [['<pre class="invalid" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~aside\n~~~')), [['<pre class="invalid" translate="no">~~~aside\n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~aside\n# \n~~~')), [['<pre class="invalid" translate="no">~~~aside\n# \n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~aside a\n# 0\n~~~')), [['<pre class="invalid" translate="no">~~~aside a\n# 0\n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`~~~aside\n# 0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~~aside\n# 0\n~~~', new Context())), [['<aside id="index::0" class="aside"><h1 id="index:random:0" class="local">0</h1><h2>References</h2><ol class="references"></ol></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~aside\n## 0\n~~~', new Context())), [['<aside id="index::0" class="aside"><h2 id="index:random:0" class="local">0</h2><h2>References</h2><ol class="references"></ol></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~aside\n# 0\n\n$-0.0\n\n## 1\n\n$test-a\n> \n~~~', new Context())), [['<aside id="index::0" class="aside"><h1 id="index:random:0" class="local">0</h1><figure data-label="$-0.0" data-group="$" hidden="" data-number="0.0"></figure><h2 id="index:random:1" class="local">1</h2><figure data-type="quote" data-label="test-a" data-group="test" data-number="1.1" id="label:random:test-a"><figcaption><span class="figindex">Test 1.1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><h2>References</h2><ol class="references"></ol></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~aside\n# 0\n~~~')), [['<aside id="index::0" class="aside"><h1 id="index:random:0" class="local">0</h1><h2>References</h2><ol class="references"></ol></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~aside\n## 0\n~~~')), [['<aside id="index::0" class="aside"><h2 id="index:random:0" class="local">0</h2><h2>References</h2><ol class="references"></ol></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~aside\n# 0\n\n$-0.0\n\n## 1\n\n$test-a\n> \n~~~')), [['<aside id="index::0" class="aside"><h1 id="index:random:0" class="local">0</h1><figure data-label="$-0.0" data-group="$" hidden="" data-number="0.0"></figure><h2 id="index:random:1" class="local">1</h2><figure data-type="quote" data-label="test-a" data-group="test" data-number="1.1" id="label:random:test-a"><figcaption><span class="figindex">Test 1.1. </span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure><h2>References</h2><ol class="references"></ol></aside>'], '']);
     });
 
   });

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

@@ -1,51 +1,80 @@
 import { ExtensionParser } from '../../block';
-import { Recursion } from '../../context';
-import { List, Node } from '../../../combinator/data/parser';
-import { recursion, block, fence, fmap } from '../../../combinator';
+import { Input, Recursion } from '../../context';
+import { Node } from '../../../combinator/parser';
+import { inits, recursion, block, fence, lazy } from '../../../combinator';
+import { document } from '../../document';
 import { identity } from '../../inline/extension/indexee';
-import { unwrap, invalid, randomID } from '../../util';
-import { parse } from '../../../api/parse';
+import { unwrap, invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
-export const aside: ExtensionParser.AsideParser = block(recursion(Recursion.block, fmap(
-  fence(/(~{3,})aside(?!\S)([^\r\n]*)(?:$|\r?\n)/y, 300),
-  // Bug: Type mismatch between outer and inner.
-  (nodes: List<Node<string>>, context) => {
-    const [body, overflow, closer, opener, delim, param] = unwrap(nodes);
-    if (!closer || overflow || param.trimStart()) return new List([
-      new Node(html('pre', {
-        class: 'invalid',
-        translate: 'no',
-        ...invalid(
-          'aside',
-          !closer || overflow ? 'fence' : 'argument',
-          !closer ? `Missing the closing delimiter "${delim}"` :
-            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-              'Invalid argument'),
-      }, `${opener}${body}${overflow || closer}`))
-    ]);
-    const references = html('ol', { class: 'references' });
-    const document = parse(body.slice(0, -1), {
-      local: true,
-      id: context.id === '' ? '' : randomID(),
-      notes: {
-        references,
-      },
-    }, context);
-    const heading = 'H1 H2 H3 H4 H5 H6'.split(' ').includes(document.firstElementChild?.tagName!) && document.firstElementChild as HTMLHeadingElement;
-    if (!heading) return new List([
-      new Node(html('pre', {
-        class: 'invalid',
-        translate: 'no',
-        ...invalid('aside', 'content', 'Missing the title at the first line'),
-      }, `${opener}${body}${closer}`))
-    ]);
-    assert(identity('index', context.id, heading));
-    return new List([
-      new Node(html('aside', { id: identity('index', context.id, heading), class: 'aside' }, [
-        document,
-        html('h2', 'References'),
-        references,
-      ]))
-    ]);
-  })));
+interface Memory {
+  readonly opener: string;
+  readonly body: string;
+  readonly closer: string;
+}
+
+export const aside: ExtensionParser.AsideParser = block(recursion(Recursion.block, inits([
+  fence(/(~{3,})aside(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true, 300),
+  (input: Input<Memory>, output) => {
+    const [body, overflow, closer, opener, delim, param] = unwrap(output.pop()) as string[];
+    if (!closer || overflow || param.trimStart()) {
+      output.append(
+        new Node(html('pre',
+          {
+            class: 'invalid',
+            translate: 'no',
+            ...invalid(
+              'aside',
+              !closer || overflow ? 'fence' : 'argument',
+              !closer ? `Missing the closing delimiter "${delim}"` :
+                overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+                  'Invalid argument'),
+          },
+          `${opener}${body}${overflow || closer}`)));
+      return;
+    }
+    input.memory = {
+      opener,
+      body,
+      closer,
+    };
+    input = input.scope.push(body);
+    input.header = true;
+    input.local = true;
+    input.notes = {
+      references: html('ol', { class: 'references' }),
+    };
+    output.push();
+    return output.context;
+  },
+  lazy(() => document),
+  (input: Input<Memory>, output) => {
+    const { notes } = input;
+    input = input.scope.pop();
+    const { memory: { opener, body, closer } } = input;
+    const doc = output.pop().head!.value;
+    const heading = 'H1 H2 H3 H4 H5 H6'.split(' ').includes(doc.firstElementChild?.tagName!) && doc.firstElementChild as HTMLHeadingElement;
+    if (!heading) {
+      return output.append(
+        new Node(html('pre',
+          {
+            class: 'invalid',
+            translate: 'no',
+            ...invalid('aside', 'content', 'Missing the title at the first line'),
+          },
+          `${opener}${body}${closer}`)));
+    }
+    assert(identity('index', input.id, heading));
+    return output.append(
+      new Node(html('aside',
+        {
+          id: identity('index', input.id, heading),
+          class: 'aside',
+        },
+        [
+          doc,
+          html('h2', 'References'),
+          notes!.references,
+        ])));
+  },
+])));

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

@@ -1,7 +1,6 @@
 import { example } from './example';
 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/example', () => {
@@ -9,26 +8,26 @@ describe('Unit: parser/block/extension/example', () => {
     const parser = some(example);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~~example/\n~~~', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/a\n~~~', new Context())), [['<pre class="invalid" translate="no">~~~example/a\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown a\n~~~', new Context())), [['<pre class="invalid" translate="no">~~~example/markdown a\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~example/markdown\n0${'\n'.repeat(301)}~~~`, new Context()), '>'), [['<pre class="invalid" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/\n~~~')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/a\n~~~')), [['<pre class="invalid" translate="no">~~~example/a\n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown a\n~~~')), [['<pre class="invalid" translate="no">~~~example/markdown a\n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`~~~example/markdown\n0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~~\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\na\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">a</pre><hr><section><p>a</p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n++a\nb++\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">++a\nb++</pre><hr><section><p><ins>a<br>b</ins></p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n$fig-a\n!https://host\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">$fig-a\n!https://host</pre><hr><section><figure data-type="media" data-label="fig-a" data-group="fig" data-number="1" id="label:random:fig-a"><figcaption><span class="figindex">Fig. 1. </span><span class="figtext"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a></div></figure><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n[$fig-a]\n!https://host\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">[$fig-a]\n!https://host</pre><hr><section><figure data-type="media" data-label="fig-a" data-group="fig" data-number="1" id="label:random:fig-a"><figcaption><span class="figindex">Fig. 1. </span><span class="figtext"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a></div></figure><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n## a\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">## a</pre><hr><section><h2 id="index:random:a" class="local">a</h2><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n~ a\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">~ a</pre><hr><section><dl><dt id="index:random:a" class="local">a</dt><dd></dd></dl><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n((a))[[b]]\n~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">((a))[[b]]</pre><hr><section><p><sup class="annotation local" id="annotation:random:ref:a:1" title="a"><a href="#annotation:random:def:a:1">*1</a></sup><sup class="reference local" id="reference:random:ref:b:1" title="b"><a href="#reference:random:def:b">[1]</a></sup></p><ol class="annotations"><li id="annotation:random:def:a:1" data-marker="*1"><span>a</span><sup><a href="#annotation:random:ref:a:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"><li id="reference:random:def:b"><span>b</span><sup><a href="#reference:random:ref:b:1">^1</a></sup></li></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~~example/markdown\na\n~~~~', new Context())), [['<aside class="example" data-type="markdown"><pre translate="no">a</pre><hr><section><p>a</p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~example/math\na\n~~~', new Context())), [['<aside class="example" data-type="math"><pre translate="no">a</pre><hr><div class="math" translate="no">$$\na\n$$</div></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~example/math\n0${'\n'.repeat(100)}~~~`, new Context()), '>'), [['<aside class="example" data-type="math">'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\na\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">a</pre><hr><section><p>a</p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n++a\nb++\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">++a\nb++</pre><hr><section><p><ins>a<br>b</ins></p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n$fig-a\n!https://host\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">$fig-a\n!https://host</pre><hr><section><figure data-type="media" data-label="fig-a" data-group="fig" data-number="1" id="label:random:fig-a"><figcaption><span class="figindex">Fig. 1. </span><span class="figtext"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a></div></figure><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n[$fig-a]\n!https://host\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">[$fig-a]\n!https://host</pre><hr><section><figure data-type="media" data-label="fig-a" data-group="fig" data-number="1" id="label:random:fig-a"><figcaption><span class="figindex">Fig. 1. </span><span class="figtext"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a></div></figure><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n## a\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">## a</pre><hr><section><h2 id="index:random:a" class="local">a</h2><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n~ a\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">~ a</pre><hr><section><dl><dt id="index:random:a" class="local">a</dt><dd></dd></dl><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n((a))[[b]]\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">((a))[[b]]</pre><hr><section><p><sup class="annotation local" id="annotation:random:ref:a:1" title="a"><a href="#annotation:random:def:a:1">*1</a></sup><sup class="reference local" id="reference:random:ref:b:1" title="b"><a href="#reference:random:def:b">[1]</a></sup></p><ol class="annotations"><li id="annotation:random:def:a:1" data-marker="*1"><span>a</span><sup><a href="#annotation:random:ref:a:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"><li id="reference:random:def:b"><span>b</span><sup><a href="#reference:random:ref:b:1">^1</a></sup></li></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~~example/markdown\na\n~~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">a</pre><hr><section><p>a</p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~example/math\na\n~~~')), [['<aside class="example" data-type="math"><pre translate="no">a</pre><hr><div class="math" translate="no">$$\na\n$$</div></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`~~~example/math\n0${'\n'.repeat(100)}~~~`), '>'), [['<aside class="example" data-type="math">'], '']);
     });
 
   });

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

@@ -1,62 +1,102 @@
 import { ExtensionParser } from '../../block';
-import { Recursion } from '../../context';
-import { List, Node, subinput } from '../../../combinator/data/parser';
-import { recursion, block, fence, fmap } from '../../../combinator';
+import { Input, Recursion } from '../../context';
+import { Result, Node } from '../../../combinator/parser';
+import { inits, recursion, block, fence, lazy } from '../../../combinator';
+import { document } from '../../document';
 import { mathblock } from '../mathblock';
-import { unwrap, invalid, randomID } from '../../util';
-import { parse } from '../../../api/parse';
+import { unwrap, invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
-export const example: ExtensionParser.ExampleParser = block(recursion(Recursion.block, fmap(
-  fence(/(~{3,})(?:example\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y, 300),
-  // Bug: Type mismatch between outer and inner.
-  (nodes: List<Node<string>>, context) => {
-    const [body, overflow, closer, opener, delim, type = 'markdown', param] = unwrap(nodes);
-    if (!closer || overflow || param.trimStart()) return new List([
-      new Node(html('pre', {
-        class: 'invalid',
-        translate: 'no',
-        ...invalid(
-          'example',
-          !closer || overflow ? 'fence' : 'argument',
-          !closer ? `Missing the closing delimiter "${delim}"` :
-            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-              'Invalid argument'),
-      }, `${opener}${body}${overflow || closer}`))
-    ]);
+interface Memory {
+  readonly body: string;
+}
+
+export const example: ExtensionParser.ExampleParser = block(recursion(Recursion.block, inits([
+  fence(/(~{3,})(?:example\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true, 300),
+  (input: Input<Memory>, output) => {
+    const [body, overflow, closer, opener, delim, type = 'markdown', param] = unwrap(output.pop()) as string[];
+    if (!closer || overflow || param.trimStart()) return output.append(
+      new Node(html('pre',
+        {
+          class: 'invalid',
+          translate: 'no',
+          ...invalid(
+            'example',
+            !closer || overflow ? 'fence' : 'argument',
+            !closer ? `Missing the closing delimiter "${delim}"` :
+              overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+                'Invalid argument'),
+        },
+        `${opener}${body}${overflow || closer}`)));
     switch (type) {
       case 'markdown': {
-        const references = html('ol', { class: 'references' });
-        const document = parse(body.slice(0, -1), {
-          local: true,
-          id: context.id === '' ? '' : randomID(),
-          notes: {
-            references,
-          },
-        }, context);
-        return new List([
-          new Node(html('aside', { class: 'example', 'data-type': 'markdown' }, [
-            html('pre', { translate: 'no' }, body.slice(0, -1)),
-            html('hr'),
-            html('section', [document, html('h2', 'References'), references]),
-          ])),
-        ]);
+        input.memory = {
+          body,
+        };
+        return contMD;
       }
       case 'math':
-        return new List([
-          new Node(html('aside', { class: 'example', 'data-type': 'math' }, [
-            html('pre', { translate: 'no' }, body.slice(0, -1)),
-            html('hr'),
-            mathblock(subinput(`$$\n${body}$$`, context))!.head!.value,
-          ])),
-        ]);
+        input.memory = {
+          body,
+        };
+        return contMath;
       default:
-        return new List([
+        return output.append(
           new Node(html('pre', {
             class: 'invalid',
             translate: 'no',
             ...invalid('example', 'type', 'Invalid example type'),
-          }, `${opener}${body}${closer}`)),
-        ]);
+          }, `${opener}${body}${closer}`)));
     }
-  })));
+  },
+])));
+
+const contMD: Result<DocumentFragment | HTMLElement, Input<Memory>> = [
+  (input, output) => {
+    input = input.scope.push(input.memory.body);
+    input.header = true;
+    input.local = true;
+    input.notes = {
+      references: html('ol', { class: 'references' }),
+    };
+    output.push();
+    return output.context;
+  },
+  lazy(() => document),
+  (input, output) => {
+    const { notes } = input;
+    input = input.scope.pop();
+    return output.append(
+      new Node(html('aside',
+        { class: 'example', 'data-type': 'markdown' },
+        [
+          html('pre', { translate: 'no' }, input.memory.body.slice(0, input.memory.body.at(-2) === '\r' ? -2 : -1)),
+          html('hr'),
+          html('section', [
+            output.pop().head!.value,
+            html('h2', 'References'),
+            notes!.references,
+          ]),
+        ])));
+  },
+];
+
+const contMath: Result<HTMLElement, Input<Memory>> = [
+  (input, output) => {
+    input.scope.push(`$$\n${input.memory.body}$$`);
+    output.push();
+    return output.context;
+  },
+  mathblock,
+  (input, output) => {
+    input = input.scope.pop();
+    return output.append(
+      new Node(html('aside',
+        { class: 'example', 'data-type': 'math' },
+        [
+          html('pre', { translate: 'no' }, input.memory.body.slice(0, input.memory.body.at(-2) === '\r' ? -2 : -1)),
+          html('hr'),
+          output.pop().head!.value,
+        ])));
+  },
+];