securemark 0.295.0 → 0.295.2

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

@@ -1,11 +1,11 @@
-import { max, min } from 'spica/alias';
 import { ExtensionParser } from '../../block';
-import { List, Data, subinput } from '../../../combinator/data/parser';
+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 { inline, medialink, media, lineshortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { unwrap, invalid } from '../../util';
 import { visualize, trimBlank, trimBlankEnd } from '../../visibility';
+import { max, min } from 'spica/alias';
 import { splice } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
@@ -25,10 +25,10 @@ export const segment_: TableParser.SegmentParser = block(
 export const table: TableParser = block(fmap(
   fence(opener, 10000),
   // Bug: Type mismatch between outer and inner.
-  (nodes: List<Data<string>>, context) => {
+  (nodes: List<Node<string>>, context) => {
     const [body, overflow, closer, opener, delim, type, param] = unwrap(nodes);
     if (!closer || overflow || param.trimStart()) return new List([
-      new Data(html('pre', {
+      new Node(html('pre', {
         class: 'invalid',
         translate: 'no',
         ...invalid(
@@ -42,13 +42,13 @@ export const table: TableParser = block(fmap(
     switch (type) {
       case 'grid':
       case undefined:
-        return (parser(subinput(body, context)) ?? new List([new Data(html('table'))]))
+        return (parser(subinput(body, context)) ?? new List([new Node(html('table'))]))
           .foldl(
-            (acc, { value }) => acc.push(new Data(define(value, { 'data-type': type }))) && acc,
+            (acc, { value }) => acc.push(new Node(define(value, { 'data-type': type }))) && acc,
             new List());
       default:
         return new List([
-          new Data(html('pre', {
+          new Node(html('pre', {
             class: 'invalid',
             translate: 'no',
             ...invalid('table', 'argument', 'Invalid table type'),
@@ -60,7 +60,7 @@ export const table: TableParser = block(fmap(
 const parser: TableParser = lazy(() => block(fmap(
   some(union([row])),
   rows => new List([
-    new Data(html('table', format([...unwrap(rows)])))
+    new Node(html('table', format([...unwrap(rows)])))
   ]))));
 
 const row: RowParser = lazy(() => dup(fmap(
@@ -75,13 +75,13 @@ const row: RowParser = lazy(() => dup(fmap(
       emptyline,
     ])),
   ]),
-  ns => Array.isArray(ns.head?.value) ? ns : ns.unshift(new Data([[]])) && ns)));
+  ns => Array.isArray(ns.head?.value) ? ns : ns.unshift(new Node([[]])) && ns)));
 
 const alignment = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)/y;
 
 const align: AlignParser = line(fmap(
   union([str(alignment)]),
-  ([{ value }]) => new List([new Data(value.split('/').map(s => s.split('')) as [string[], string[]?])])));
+  ([{ value }]) => new List([new Node(value.split('/').map(s => s.split('')) as [string[], string[]?])])));
 
 const delimiter = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)|[#:](?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \n])/y;
 
@@ -104,7 +104,7 @@ const head: CellParser.HeadParser = block(fmap(open(
       open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlank(some(inline))), true),
     ])),
   true),
-  ns => new List([new Data(html('th', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),
+  ns => new List([new Node(html('th', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),
   false);
 
 const data: CellParser.DataParser = block(fmap(open(
@@ -126,7 +126,7 @@ const data: CellParser.DataParser = block(fmap(open(
       open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlankEnd(some(inline))), true),
     ])),
   true),
-  ns => new List([new Data(html('td', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),
+  ns => new List([new Node(html('td', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),
   false);
 
 const dataline: CellParser.DatalineParser = line(
@@ -166,7 +166,7 @@ function attributes(source: string): Record<string, string | undefined> {
   };
 }
 
-function format(rows: List<Data<[string[], string[]?] | HTMLTableCellElement>>[]): HTMLTableSectionElement[] {
+function format(rows: List<Node<[string[], string[]?] | HTMLTableCellElement>>[]): HTMLTableSectionElement[] {
   const thead = html('thead');
   const tbody = html('tbody');
   const tfoot = html('tfoot');
@@ -180,7 +180,7 @@ function format(rows: List<Data<[string[], string[]?] | HTMLTableCellElement>>[]
   let cnt = 0;
   for (const list of rows) ROW: for (let i = cnt++; i < cnt; ++i) {
     // Copy to make them retryable.
-    const [{ value: [[...as], [...vs] = []] }, ...cells] = list as any as [Data<[string[], string[]?]>, ...Data<HTMLTableCellElement>[]];
+    const [{ value: [[...as], [...vs] = []] }, ...cells] = list as any as [Node<[string[], string[]?]>, ...Node<HTMLTableCellElement>[]];
     let isBody = target === tfoot
       ? false
       : 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';
 
 describe('Unit: parser/block/extension', () => {
   describe('extension', () => {
-    const parser = (source: string) => some(extension)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(extension);
 
     it('invalid', () => {
-      assert(!parser(''));
-      assert(!parser('\n'));
-      assert(!parser('~~~'));
-      assert(!parser('~~~\n'));
-      assert(!parser('~~~\n\n'));
-      assert(parser('~~~\na~~~'));
-      assert(parser('~~~\n~~~'));
-      assert(parser('~~~\na\n~~~'));
-      assert(!parser('~~~a'));
-      assert(!parser('~~~a ~~~\n~~~'));
-      assert(!parser('~~~a\n'));
-      assert(!parser('~~~a\n\n'));
-      assert(parser('~~~a\nb~~~'));
-      assert(!parser(' ~~~a\n~~~'));
-      assert(!parser('$-name'));
-      assert(!parser('$-name-0'));
-      assert(!parser('$group-0'));
+      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())));
     });
 
     it('valid', () => {
-      assert(parser('~~~a\n~~~'));
-      assert(parser('~~~a\nb\n~~~'));
-      assert(parser('$-0'));
-      assert(parser('$-0\n'));
-      assert(parser('$-0\n\n'));
+      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())));
     });
 
   });

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

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

package/src/parser/block/heading.ts

@@ -1,6 +1,6 @@
 import { HeadingParser } from '../block';
 import { State } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, some, state, block, line, focus, rewrite, open, fmap, firstline } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { str } from '../source';
@@ -12,11 +12,11 @@ export const segment: HeadingParser.SegmentParser = block(focus(
   /#+ +\S[^\n]*(?:\n#+(?=$|[ \n])[^\n]*)*(?:$|\n)/y,
   input => {
     const { context } = input;
-    const { source, range = 0 } = context;
-    const acc = new List<Data<string>>();
+    const { source, range } = context;
+    const acc = new List<Node<string>>();
     for (const len = context.position + range; context.position < len;) {
       const line = firstline(source, context.position);
-      acc.push(new Data(line));
+      acc.push(new Node(line));
       context.position += line.length;
     }
     return acc;
@@ -38,10 +38,10 @@ export const heading: HeadingParser = block(rewrite(segment,
     const [h, ...ns] = unwrap(nodes) as [string, ...(HTMLElement | string)[]];
     return new List([
       h.length <= 6
-        ? new Data(html(`h${h.length as 1}`, { 'data-index': dataindex(nodes) }, defrag(ns)))
-        : new Data(html(`h6`, {
+        ? 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)))
+        }, context.source.slice(context.position - context.range, context.position)))
     ]);
   }))))));

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

@@ -1,23 +1,19 @@
 import { ilist } from './ilist';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 
 describe('Unit: parser/block/ilist', () => {
   describe('ilist', () => {
-    const parser = (source: string) => some(ilist)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(ilist);
 
     it('single', () => {
-      assert(!parser('-'));
-      assert(!parser('+'));
-      assert(!parser('*'));
-      assert(!parser(' * '));
-      assert(parser('- '));
-      assert(parser('+ '));
-      assert(parser('* '));
-      assert(parser('- \n-'));
-      assert(parser('+ \n+'));
-      assert(parser('* \n*'));
+      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())));
     });
 
   });

package/src/parser/block/ilist.ts

@@ -1,7 +1,7 @@
 import { IListParser } from '../block';
 import { Parser } from '../../combinator/data/parser';
 import { Recursion } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/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';
@@ -24,20 +24,20 @@ export const ilist_: IListParser = lazy(() => block(fmap(validate(
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
-      ns => new List([new Data(html('li', defrag(unwrap(fillFirstLine(ns)))))])),
+      ns => new List([new Node(html('li', defrag(unwrap(fillFirstLine(ns)))))])),
   ])))),
   ns => new List([
-    new Data(html('ul', {
+    new Node(html('ul', {
       class: 'invalid',
       ...invalid('list', 'syntax', 'Use "-" instead of "+" or "*"'),
     }, unwrap(ns))),
   ]))));
 
 export const ilistitem = rewrite(
-  inits([contentline, indent<Parser<string>>(({ context: { source } }) => new List([new Data(source)]))]),
+  inits([contentline, indent<Parser<string>>(({ context: { source } }) => new List([new Node(source)]))]),
   ({ context: { source } }) => new List([
-    new Data(''),
-    new Data(html('span', {
+    new Node(''),
+    new Node(html('span', {
       class: 'invalid',
       ...invalid('list', 'syntax', 'Fix the indent or the head of the list item'),
     }, source.replace('\n', '')))

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

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

package/src/parser/block/mathblock.ts

@@ -1,5 +1,5 @@
 import { MathBlockParser } from '../block';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { block, fence, clear, fmap } from '../../combinator';
 import { unwrap, invalid } from '../util';
 import { html } from 'typed-dom/dom';
@@ -19,9 +19,9 @@ export const mathblock: MathBlockParser = block(fmap(
     const [body, overflow, closer, opener, delim, param] = unwrap<string>(nodes);
     return new List([
       delim.length === 2 && closer && !overflow && param.trimStart() === ''
-        ? new Data(cache?.get(`${delim}\n${body}${delim}`)?.cloneNode(true) as HTMLDivElement ||
+        ? new Node(cache?.get(`${delim}\n${body}${delim}`)?.cloneNode(true) as HTMLDivElement ||
           html('div', { class: 'math', translate: 'no' }, `${delim}\n${body}${delim}`))
-        : new Data(html('pre', {
+        : new Node(html('pre', {
             class: 'invalid',
             translate: 'no',
             ...invalid(

package/src/parser/block/mediablock.ts

@@ -1,5 +1,5 @@
 import { MediaBlockParser } from '../block';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, inits, some, block, line, fallback, fmap } from '../../combinator';
 import { medialink, media, lineshortmedia } from '../inline';
 import { unwrap, invalid } from '../util';
@@ -17,9 +17,9 @@ export const mediablock: MediaBlockParser = block(fmap(
       media,
       lineshortmedia,
     ]), ({ context: { source } }) => new List([
-      new Data(html('span', {
+      new Node(html('span', {
       class: 'invalid',
       ...invalid('mediablock', 'syntax', 'Not media syntax'),
     }, source.replace('\n', '')))
     ]))))]),
-  ns => new List([new Data(html('div', unwrap(ns)))])));
+  ns => new List([new Node(html('div', unwrap(ns)))])));