securemark 0.295.0 → 0.295.2

package/src/parser/inline/bracket.test.ts

@@ -1,91 +1,91 @@
 import { bracket } from './bracket';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/bracket', () => {
   describe('bracket', () => {
-    const parser = (source: string) => some(bracket)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(bracket);
 
     it('(', () => {
-      assert.deepStrictEqual(inspect(parser('('), ctx), [['('], '']);
-      assert.deepStrictEqual(inspect(parser('()'), ctx), [['<span class="paren">()</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(a'), ctx), [['(', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('(0)'), ctx), [['(', '0', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(1)'), ctx), [['(', '1', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(10)'), ctx), [['(', '10', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(2000)'), ctx), [['(', '2000', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(0-1)'), ctx), [['(', '0-1', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(0)-1'), ctx), [['(', '0', ')'], '-1']);
-      assert.deepStrictEqual(inspect(parser('(0.1)'), ctx), [['(', '0.1', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(0.1.2)'), ctx), [['(', '0.1.2', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(1.1, 1.2-1.3, 1.4)'), ctx), [['(', '1.1, 1.2-1.3, 1.4', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(1 2)'), ctx), [['<span class="paren">(1 2)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(1, 2)'), ctx), [['(', '1, 2', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(1a)'), ctx), [['(', '1a', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(a)'), ctx), [['(', 'a', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(a1)'), ctx), [['(', 'a1', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(a-1)'), ctx), [['(', 'a-1', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(a.1)'), ctx), [['(', 'a.1', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(a b)'), ctx), [['<span class="paren">(a b)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(word)'), ctx), [['(', 'word', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(word word)'), ctx), [['<span class="paren">(word word)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(word, word)'), ctx), [['(', 'word, word', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(A)'), ctx), [['(', 'A', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(Name)'), ctx), [['(', 'Name', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(Word word)'), ctx), [['<span class="paren">(Word word)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(Word Word)'), ctx), [['<span class="paren">(Word Word)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(Name, Name)'), ctx), [['(', 'Name, Name', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(ABBR)'), ctx), [['(', 'ABBR', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(ABBR, ABBR)'), ctx), [['(', 'ABBR, ABBR', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(\\a)'), ctx), [['<span class="paren">(a)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(==)'), ctx), [['<span class="paren">(==)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('("(\n))"(")'), ctx), [['<span class="paren">("(<br>)</span>'], ')"(")']);
-      assert.deepStrictEqual(inspect(parser('($)$'), ctx), [['(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser(')'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('（１，２）'), ctx), [['（', '１，２', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('（０－１）'), ctx), [['（', '０－１', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('（０．１）'), ctx), [['（', '０．１', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('（ａ）'), ctx), [['（', 'ａ', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('（Ａ）'), ctx), [['（', 'Ａ', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('（Ａ，Ｂ）'), ctx), [['（', 'Ａ，Ｂ', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('（Ａ、Ｂ）'), ctx), [['（', 'Ａ、Ｂ', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('(<bdi>a\\\nb</bdi>)'), ctx), [['<span class="paren">(<bdi>a<br>b</bdi>)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('([% a\\\nb %])'), ctx), [['<span class="paren">(<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('({{\\\n}})'), ctx), [['<span class="paren">(<span class="template">{{\\<br>}}</span>)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(', new Context())), [['('], '']);
+      assert.deepStrictEqual(inspect(parser, input('()', new Context())), [['<span class="paren">()</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(a', new Context())), [['(', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(0)', new Context())), [['(', '0', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1)', new Context())), [['(', '1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(10)', new Context())), [['(', '10', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(2000)', new Context())), [['(', '2000', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(0-1)', new Context())), [['(', '0-1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(0)-1', new Context())), [['(', '0', ')'], '-1']);
+      assert.deepStrictEqual(inspect(parser, input('(0.1)', new Context())), [['(', '0.1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(0.1.2)', new Context())), [['(', '0.1.2', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1.1, 1.2-1.3, 1.4)', new Context())), [['(', '1.1, 1.2-1.3, 1.4', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1 2)', new Context())), [['<span class="paren">(1 2)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1, 2)', new Context())), [['(', '1, 2', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(1a)', new Context())), [['(', '1a', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(a)', new Context())), [['(', 'a', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(a1)', new Context())), [['(', 'a1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(a-1)', new Context())), [['(', 'a-1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(a.1)', new Context())), [['(', 'a.1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(a b)', new Context())), [['<span class="paren">(a b)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(word)', new Context())), [['(', 'word', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(word word)', new Context())), [['<span class="paren">(word word)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(word, word)', new Context())), [['(', 'word, word', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(A)', new Context())), [['(', 'A', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(Name)', new Context())), [['(', 'Name', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(Word word)', new Context())), [['<span class="paren">(Word word)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(Word Word)', new Context())), [['<span class="paren">(Word Word)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(Name, Name)', new Context())), [['(', 'Name, Name', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(ABBR)', new Context())), [['(', 'ABBR', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(ABBR, ABBR)', new Context())), [['(', 'ABBR, ABBR', ')'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(\\a)', new Context())), [['<span class="paren">(a)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(==)', new Context())), [['<span class="paren">(==)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('("(\n))"(")', new Context())), [['<span class="paren">("(<br>)</span>'], ')"(")']);
+      assert.deepStrictEqual(inspect(parser, input('($)$', new Context())), [['(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(')', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('（１，２）', new Context())), [['（', '１，２', '）'], '']);
+      assert.deepStrictEqual(inspect(parser, input('（０－１）', new Context())), [['（', '０－１', '）'], '']);
+      assert.deepStrictEqual(inspect(parser, input('（０．１）', new Context())), [['（', '０．１', '）'], '']);
+      assert.deepStrictEqual(inspect(parser, input('（ａ）', new Context())), [['（', 'ａ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser, input('（Ａ）', new Context())), [['（', 'Ａ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser, input('（Ａ，Ｂ）', new Context())), [['（', 'Ａ，Ｂ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser, input('（Ａ、Ｂ）', new Context())), [['（', 'Ａ、Ｂ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser, input('(<bdi>a\\\nb</bdi>)', new Context())), [['<span class="paren">(<bdi>a<br>b</bdi>)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('([% a\\\nb %])', new Context())), [['<span class="paren">(<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('({{\\\n}})', new Context())), [['<span class="paren">(<span class="template">{{\\<br>}}</span>)</span>'], '']);
     });
 
     it('[', () => {
-      assert.deepStrictEqual(inspect(parser('['), ctx), [['['], '']);
-      assert.deepStrictEqual(inspect(parser('[]'), ctx), [['[', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[a'), ctx), [['[', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('[a]'), ctx), [['[', 'a', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[==]'), ctx), [['[', '==', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[$]$'), ctx), [['[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser(']'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[', new Context())), [['['], '']);
+      assert.deepStrictEqual(inspect(parser, input('[]', new Context())), [['[', ']'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[a', new Context())), [['[', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[a]', new Context())), [['[', 'a', ']'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[==]', new Context())), [['[', '==', ']'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[$]$', new Context())), [['[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(']', new Context())), undefined);
     });
 
     it('{', () => {
-      assert.deepStrictEqual(inspect(parser('{'), ctx), [['{'], '']);
-      assert.deepStrictEqual(inspect(parser('{}'), ctx), [['{', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('{a'), ctx), [['{', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('{a}'), ctx), [['{', 'a', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('{==}'), ctx), [['{', '==', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('}'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('{', new Context())), [['{'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{}', new Context())), [['{', '}'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{a', new Context())), [['{', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{a}', new Context())), [['{', 'a', '}'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{==}', new Context())), [['{', '==', '}'], '']);
+      assert.deepStrictEqual(inspect(parser, input('}', new Context())), undefined);
     });
 
     it('"', () => {
-      assert.deepStrictEqual(inspect(parser('"'), ctx), [['"'], '']);
-      assert.deepStrictEqual(inspect(parser('""'), ctx), [['"', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"a'), ctx), [['"', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('"a"'), ctx), [['"', 'a', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(")"'), ctx), [['"', '(', '"'], ')"']);
-      assert.deepStrictEqual(inspect(parser('"(("'), ctx), [['"', '(', '(', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(\\")"'), ctx), [['"', '<span class="paren">(")</span>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(\n)"(")'), ctx), [['"', '('], '\n)"(")']);
-      assert.deepStrictEqual(inspect(parser('"\n"'), ctx), [['"'], '\n"']);
-      assert.deepStrictEqual(inspect(parser('"\n"(")'), ctx), [['"'], '\n"(")']);
+      assert.deepStrictEqual(inspect(parser, input('"', new Context())), [['"'], '']);
+      assert.deepStrictEqual(inspect(parser, input('""', new Context())), [['"', '"'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"a', new Context())), [['"', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"a"', new Context())), [['"', 'a', '"'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"(")"', new Context())), [['"', '(', '"'], ')"']);
+      assert.deepStrictEqual(inspect(parser, input('"(("', new Context())), [['"', '(', '(', '"'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"(\\")"', new Context())), [['"', '<span class="paren">(")</span>', '"'], '']);
+      assert.deepStrictEqual(inspect(parser, input('"(\n)"(")', new Context())), [['"', '('], '\n)"(")']);
+      assert.deepStrictEqual(inspect(parser, input('"\n"', new Context())), [['"'], '\n"']);
+      assert.deepStrictEqual(inspect(parser, input('"\n"(")', new Context())), [['"'], '\n"(")']);
     });
 
   });

package/src/parser/inline/bracket.ts

@@ -1,6 +1,6 @@
 import { BracketParser } from '../inline';
 import { State, Recursion, Backtrack } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
@@ -40,37 +40,35 @@ const p1 = lazy(() => surround(
   str(')'),
   true, [],
   ([as, bs = new List(), cs], context) => {
-    const { source, position, range = 0 } = context;
+    const { source, position, range } = context;
     const head = position - range;
-    if (context.linebreak !== 0 || source[position - 2] !== ')' || source[head + 1] !== '(') {
-      setBacktrack(context, 2 | Backtrack.doublebracket, head);
+    if (context.linebreak !== 0) {
+      if (head > 0 && source[head - 1] === '(') {
+        setBacktrack(context, 2 | Backtrack.doublebracket, head - 1);
+      }
+    }
+    else if (source[position] !== ')' && source[head - 1] === '(') {
+      setBacktrack(context, 2 | Backtrack.doublebracket, head - 1);
     }
     const str = source.slice(position - range + 1, position - 1);
     return indexA.test(str)
-      ? new List([new Data(as.head!.value), new Data(str), new Data(cs.head!.value)])
-      : new List([new Data(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))]);
+      ? new List([new Node(as.head!.value), new Node(str), new Node(cs.head!.value)])
+      : new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
   },
-  ([as, bs = new List()], context) => {
-    const { source, position, range = 0 } = context;
-    const head = position - range;
-    if (context.linebreak !== 0 || source[head + 1] !== '(') {
-      setBacktrack(context, 2 | Backtrack.doublebracket, head);
-    }
-    return as.import(bs as List<Data<string>>);
-  }));
+  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
 
 const p2 = lazy(() => surround(
   str('（'),
   precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
   str('）'),
   true, [],
-  ([as, bs = [], cs], { source, position, range = 0 }) => {
+  ([as, bs = [], cs], { source, position, range }) => {
     const str = source.slice(position - range + 1, position - 1);
     return indexF.test(str)
-      ? new List([new Data(as.head!.value), new Data(str), new Data(cs.head!.value)])
-      : new List([new Data(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))]);
+      ? new List([new Node(as.head!.value), new Node(str), new Node(cs.head!.value)])
+      : new List([new Node(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))]);
   },
-  ([as, bs = new List()]) => as.import(bs as List<Data<string>>)));
+  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
 
 const s1 = lazy(() => surround(
   str('['),
@@ -79,20 +77,25 @@ const s1 = lazy(() => surround(
   true,
   [2 | Backtrack.common],
   ([as, bs = new List(), cs], context) => {
-    if (context.state! & State.link) {
-      const { source, position, range = 0 } = context;
-      const head = position - range;
-      if (context.linebreak !== 0 || source[position - 2] !== ']' || source[head + 1] !== '[') {
-        setBacktrack(context, 2 | Backtrack.doublebracket, head);
+    const { source, position, range } = context;
+    const head = position - range;
+    if (context.linebreak !== 0) {
+      if (head > 0 && source[head - 1] === '[') {
+        setBacktrack(context, 2 | Backtrack.doublebracket, head - 1);
       }
+    }
+    else if (source[position] !== ']' && source[head - 1] === '[') {
+      setBacktrack(context, 2 | Backtrack.doublebracket, head - 1);
+    }
+    if (context.state & State.link) {
       if (context.linebreak !== 0) {
-        setBacktrack(context, 2 | Backtrack.doublebracket | Backtrack.link | Backtrack.ruby, head);
+        setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head);
       }
       else if (source[position] !== '{') {
         setBacktrack(context, 2 | Backtrack.link, head);
       }
       else {
-        context.state! ^= State.link;
+        context.state ^= State.link;
         const result = !isBacktrack(context, 1 | Backtrack.link)
           ? textlink({ context })
           : undefined;
@@ -100,13 +103,13 @@ const s1 = lazy(() => surround(
         if (!result) {
           setBacktrack(context, 2 | Backtrack.link, head);
         }
-        context.state! ^= State.link;
+        context.state ^= State.link;
         context.range = range;
       }
     }
-    return as.import(bs as List<Data<string>>).import(cs);
+    return as.import(bs as List<Node<string>>).import(cs);
   },
-  ([as, bs = new List()]) => as.import(bs as List<Data<string>>)));
+  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
 
 const s2 = lazy(() => surround(
   str('［'),
@@ -114,7 +117,7 @@ const s2 = lazy(() => surround(
   str('］'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Data<string>>)));
+  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
 
 const c1 = lazy(() => surround(
   str('{'),
@@ -122,7 +125,7 @@ const c1 = lazy(() => surround(
   str('}'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Data<string>>)));
+  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
 
 const c2 = lazy(() => surround(
   str('｛'),
@@ -130,7 +133,7 @@ const c2 = lazy(() => surround(
   str('｝'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Data<string>>)));
+  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));
 
 const d1 = lazy(() => surround(
   str('"'),
@@ -139,4 +142,4 @@ const d1 = lazy(() => surround(
   str('"'),
   true, [],
   undefined,
-  ([as, bs = new List()]) => as.import(bs as List<Data<string>>)));
+  ([as, bs = new List()]) => as.import(bs as List<Node<string>>)));

package/src/parser/inline/code.test.ts

@@ -1,55 +1,55 @@
 import { code } from './code';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/code', () => {
   describe('code', () => {
-    const parser = (source: string) => some(code)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(code);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('`'), ctx), [['`'], '']);
-      assert.deepStrictEqual(inspect(parser('``'), ctx), [['``'], '']);
-      assert.deepStrictEqual(inspect(parser('``a`'), ctx), [['<code class="invalid">``a`</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`a``'), ctx), [ [ '<code class="invalid">`a``</code>' ], '' ]);
-      assert.deepStrictEqual(inspect(parser('`\n`'), ctx), [['`'], '\n`']);
-      assert.deepStrictEqual(inspect(parser('`a\nb`'), ctx), [['<code class="invalid">`a</code>'], '\nb`']);
-      assert.deepStrictEqual(inspect(parser('`a\\\nb`'), ctx), [['<code class="invalid">`a\\</code>'], '\nb`']);
-      assert.deepStrictEqual(inspect(parser(' ` `'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('`', new Context())), [['`'], '']);
+      assert.deepStrictEqual(inspect(parser, input('``', new Context())), [['``'], '']);
+      assert.deepStrictEqual(inspect(parser, input('``a`', new Context())), [['<code class="invalid">``a`</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a``', new Context())), [ [ '<code class="invalid">`a``</code>' ], '' ]);
+      assert.deepStrictEqual(inspect(parser, input('`\n`', new Context())), [['`'], '\n`']);
+      assert.deepStrictEqual(inspect(parser, input('`a\nb`', new Context())), [['<code class="invalid">`a</code>'], '\nb`']);
+      assert.deepStrictEqual(inspect(parser, input('`a\\\nb`', new Context())), [['<code class="invalid">`a\\</code>'], '\nb`']);
+      assert.deepStrictEqual(inspect(parser, input(' ` `', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('` `'), ctx), [['<code data-src="` `"> </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`  `'), ctx), [['<code data-src="`  `">  </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`   `'), ctx), [['<code data-src="`   `">   </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`a`'), ctx), [['<code data-src="`a`">a</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`ab`'), ctx), [['<code data-src="`ab`">ab</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`a`b'), ctx), [['<code data-src="`a`">a</code>'], 'b']);
-      assert.deepStrictEqual(inspect(parser('`a`b`'), ctx), [['<code data-src="`a`">a</code>'], 'b`']);
-      assert.deepStrictEqual(inspect(parser('`a`\n'), ctx), [['<code data-src="`a`">a</code>'], '\n']);
+      assert.deepStrictEqual(inspect(parser, input('` `', new Context())), [['<code data-src="` `"> </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`  `', new Context())), [['<code data-src="`  `">  </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`   `', new Context())), [['<code data-src="`   `">   </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a`', new Context())), [['<code data-src="`a`">a</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`ab`', new Context())), [['<code data-src="`ab`">ab</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a`b', new Context())), [['<code data-src="`a`">a</code>'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('`a`b`', new Context())), [['<code data-src="`a`">a</code>'], 'b`']);
+      assert.deepStrictEqual(inspect(parser, input('`a`\n', new Context())), [['<code data-src="`a`">a</code>'], '\n']);
     });
 
     it('escape', () => {
-      assert.deepStrictEqual(inspect(parser('`\\`'), ctx), [['<code data-src="`\\`">\\</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`\\\\`'), ctx), [['<code data-src="`\\\\`">\\\\</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`&nbsp;`'), ctx), [['<code data-src="`&amp;nbsp;`">&amp;nbsp;</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('` `` `'), ctx), [['<code data-src="` `` `">``</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`` ` ``'), ctx), [['<code data-src="`` ` ``">`</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`\\`', new Context())), [['<code data-src="`\\`">\\</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`\\\\`', new Context())), [['<code data-src="`\\\\`">\\\\</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`&nbsp;`', new Context())), [['<code data-src="`&amp;nbsp;`">&amp;nbsp;</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('` `` `', new Context())), [['<code data-src="` `` `">``</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`` ` ``', new Context())), [['<code data-src="`` ` ``">`</code>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('`<wbr>`'), ctx), [['<code data-src="`&lt;wbr&gt;`">&lt;wbr&gt;</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`*u*`'), ctx), [['<code data-src="`*u*`">*u*</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`<wbr>`', new Context())), [['<code data-src="`&lt;wbr&gt;`">&lt;wbr&gt;</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`*u*`', new Context())), [['<code data-src="`*u*`">*u*</code>'], '']);
     });
 
     it('trim', () => {
-      assert.deepStrictEqual(inspect(parser('`a `'), ctx), [['<code data-src="`a `">a </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('` a`'), ctx), [['<code data-src="` a`"> a</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('` a `'), ctx), [['<code data-src="` a `"> a </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`  a  `'), ctx), [['<code data-src="`  a  `">  a  </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`\ta\t`'), ctx), [['<code data-src="`\ta\t`">\ta\t</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`a `', new Context())), [['<code data-src="`a `">a </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('` a`', new Context())), [['<code data-src="` a`"> a</code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('` a `', new Context())), [['<code data-src="` a `"> a </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`  a  `', new Context())), [['<code data-src="`  a  `">  a  </code>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('`\ta\t`', new Context())), [['<code data-src="`\ta\t`">\ta\t</code>'], '']);
     });
 
   });

package/src/parser/inline/code.ts

@@ -1,5 +1,5 @@
 import { CodeParser } from '../inline';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { match } from '../../combinator';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
@@ -8,13 +8,13 @@ export const code: CodeParser = match(
   /(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|(?=$|\n))/y,
   ([whole, opener, body, closer]) => () =>
     closer
-      ? new List([new Data(html('code', { 'data-src': whole }, format(body)))])
+      ? new List([new Node(html('code', { 'data-src': whole }, format(body)))])
       : body
-        ? new List([new Data(html('code', {
+        ? new List([new Node(html('code', {
             class: 'invalid',
             ...invalid('code', 'syntax', `Missing the closing symbol "${opener}"`)
           }, whole))])
-        : new List([new Data(opener)]));
+        : new List([new Node(opener)]));
 
 function format(text: string): string {
   return text.length > 2

package/src/parser/inline/deletion.test.ts

@@ -1,46 +1,46 @@
 import { deletion } from './deletion';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/deletion', () => {
   describe('deletion', () => {
-    const parser = (source: string) => some(deletion)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(deletion);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('~'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('~~'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('~~a'), ctx), [['~~', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a~'), ctx), [['~~', 'a~'], '']);
-      assert.deepStrictEqual(inspect(parser(' ~~a~~'), ctx), 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('~~a', new Context())), [['~~', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~', new Context())), [['~~', 'a~'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' ~~a~~', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('~~a~~'), ctx), [['<del>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a~b~~'), ctx), [['<del>a~b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~ ~~'), ctx), [['<del> </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~ a~~'), ctx), [['<del> a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~ a ~~'), ctx), [['<del> a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~  a  ~~'), ctx), [['<del> a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~\na~~'), ctx), [['<del><br>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~\\\na~~'), ctx), [['<del><br>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~<wbr>a~~'), ctx), [['<del><wbr>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a ~~'), ctx), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a \n ~~'), ctx), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\n~~'), ctx), [['<del>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\n ~~'), ctx), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\n<wbr>~~'), ctx), [['<del>a<wbr></del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\nb~~'), ctx), [['<del>a<br>b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\\\nb~~'), ctx), [['<del>a<br>b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~\\~~~'), ctx), [['<del>~</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a~~~'), ctx), [['<del>a</del>'], '~']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~~', new Context())), [['<del>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~b~~', new Context())), [['<del>a~b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~ ~~', new Context())), [['<del> </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~ a~~', new Context())), [['<del> a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~ a ~~', new Context())), [['<del> a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~  a  ~~', new Context())), [['<del> a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~\na~~', new Context())), [['<del><br>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~\\\na~~', new Context())), [['<del><br>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~<wbr>a~~', new Context())), [['<del><wbr>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a ~~', new Context())), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a \n ~~', new Context())), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\n~~', new Context())), [['<del>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\n ~~', new Context())), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\n<wbr>~~', new Context())), [['<del>a<wbr></del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\nb~~', new Context())), [['<del>a<br>b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a\\\nb~~', new Context())), [['<del>a<br>b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~\\~~~', new Context())), [['<del>~</del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~a~~~', new Context())), [['<del>a</del>'], '~']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('~~*~~a~~*~~'), ctx), [['<del><em><del>a</del></em></del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~*++a++*~~'), ctx), [['<del><em><ins>a</ins></em></del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~*~~a~~*~~', new Context())), [['<del><em><del>a</del></em></del>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~*++a++*~~', new Context())), [['<del><em><ins>a</ins></em></del>'], '']);
     });
 
   });

package/src/parser/inline/deletion.ts

@@ -1,6 +1,6 @@
 import { DeletionParser } from '../inline';
 import { Recursion, Command } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { blankWith } from '../visibility';
@@ -17,6 +17,6 @@ export const deletion: DeletionParser = lazy(() =>
     ]))),
     '~~',
     false, [],
-    ([, bs], { buffer }) => buffer!.import(bs),
-    ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
-    nodes => new List([new Data(html('del', defrag(unwrap(nodes))))]))));
+    ([, bs], { buffer }) => buffer.import(bs),
+    ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
+    nodes => new List([new Node(html('del', defrag(unwrap(nodes))))]))));