securemark 0.295.0 → 0.295.2

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

@@ -1,60 +1,60 @@
 import { ruby } from './ruby';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/ruby', () => {
   describe('ruby', () => {
-    const parser = (source: string) => some(ruby)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(ruby);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[(b)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[]()'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[](b)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[ ](b)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[ a](b)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[	a](b)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[	 a](b)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[&a;](b)'), ctx), [['<ruby>&amp;a;<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[a](&a;)'), ctx), [['<ruby>a<rp>(</rp><rt>&amp;a;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[<wbr>](a)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[a](<wbr>)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[a]()'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[a]( )'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[a\nb](c)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[a](b\nc)'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' [a](b)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[(b)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[]()', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[](b)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ ](b)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ a](b)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[&Tab;a](b)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[&Tab; a](b)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[&a;](b)', new Context())), [['<ruby>&amp;a;<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[a](&a;)', new Context())), [['<ruby>a<rp>(</rp><rt>&amp;a;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[<wbr>](a)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a](<wbr>)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a]()', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a]( )', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a\nb](c)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a](b\nc)', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' [a](b)', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('[A](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A](ab)'), ctx), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A ](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A ](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A ](a b )'), ctx), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A  ](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp><rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A \\ ](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp> <rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a)'), ctx), [['<ruby>AB<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a )'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB]( b)'), ctx), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](ab)'), ctx), [['<ruby>AB<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a b )'), ctx), [['<ruby>AB<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a b c)'), ctx), [['<ruby>AB<rp>(</rp><rt>a b c</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A B](ab)'), ctx), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A B](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[ABC]( b )'), ctx), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[ABC](a  c)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[東方](とう　ほう)'), ctx), [['<ruby>東<rp>(</rp><rt>とう</rt><rp>)</rp>方<rp>(</rp><rt>ほう</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[秦　\\　　こころ](はた　の　こころ)'), ctx), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>　<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[秦　&nbsp;　こころ](はた　の　こころ)'), ctx), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>&nbsp;<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[&&](&&)'), ctx), [['<ruby>&amp;&amp;<rp>(</rp><rt>&amp;&amp;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[&copy;](&copy;)'), ctx), [['<ruby>©<rp>(</rp><rt>©</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[&amp;copy;](&amp;copy;)'), ctx), [['<ruby>&amp;copy;<rp>(</rp><rt>&amp;copy;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[*A*](*a*)'), ctx), [['<ruby>*A*<rp>(</rp><rt>*a*</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A](ab)', new Context())), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A ](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A ](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A ](a b )', new Context())), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A  ](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp><rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A \\ ](a)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp> <rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a)', new Context())), [['<ruby>AB<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a )', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB]( b)', new Context())), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](ab)', new Context())), [['<ruby>AB<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a b )', new Context())), [['<ruby>AB<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[AB](a b c)', new Context())), [['<ruby>AB<rp>(</rp><rt>a b c</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A B](ab)', new Context())), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A B](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC]( b )', new Context())), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](a  c)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[東方](とう　ほう)', new Context())), [['<ruby>東<rp>(</rp><rt>とう</rt><rp>)</rp>方<rp>(</rp><rt>ほう</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[秦　\\　　こころ](はた　の　こころ)', new Context())), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>　<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[秦　&nbsp;　こころ](はた　の　こころ)', new Context())), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>&nbsp;<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[&&](&&)', new Context())), [['<ruby>&amp;&amp;<rp>(</rp><rt>&amp;&amp;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[&copy;](&copy;)', new Context())), [['<ruby>©<rp>(</rp><rt>©</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[&amp;copy;](&amp;copy;)', new Context())), [['<ruby>&amp;copy;<rp>(</rp><rt>&amp;copy;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[*A*](*a*)', new Context())), [['<ruby>*A*<rp>(</rp><rt>*a*</rt><rp>)</rp></ruby>'], '']);
     });
 
   });

package/src/parser/inline/ruby.ts

@@ -1,6 +1,6 @@
 import { RubyParser } from '../inline';
 import { Backtrack } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { inits, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { txt } from '../source';
@@ -25,38 +25,38 @@ export const ruby: RubyParser = lazy(() => bind(
   ]),
   ([{ value: texts }, { value: rubies = undefined } = {}], context) => {
     if (rubies === undefined) {
-      const head = context.position - context.range!;
+      const head = context.position - context.range;
       return void setBacktrack(context, 2 | Backtrack.ruby, head);
     }
     switch (true) {
       case texts.length >= rubies.length:
         return new List([
-          new Data(html('ruby', defrag(unwrap([...zip(texts, rubies)]
+          new Node(html('ruby', defrag(unwrap([...zip(texts, rubies)]
             .reduce((acc, [{ value: text = '' } = {}, { value: ruby = '' } = {}]) =>
               acc.import(
                 ruby
-                  ? new List([new Data(text), new Data(html('rp', '(')), new Data(html('rt', ruby)), new Data(html('rp', ')'))])
-                  : new List([new Data(text), new Data(html('rt'))]))
-            , new List<Data<string | HTMLElement>>()))))),
+                  ? new List([new Node(text), new Node(html('rp', '(')), new Node(html('rt', ruby)), new Node(html('rp', ')'))])
+                  : new List([new Node(text), new Node(html('rt'))]))
+            , new List<Node<string | HTMLElement>>()))))),
         ]);
       case texts.length === 1 && [...texts.head!.value].length >= rubies.length:
         return new List([
-          new Data(html('ruby', defrag(unwrap([...zip(new List([...texts.head!.value].map(char => new Data(char))), rubies)]
+          new Node(html('ruby', defrag(unwrap([...zip(new List([...texts.head!.value].map(char => new Node(char))), rubies)]
             .reduce((acc, [{ value: text = '' } = {}, { value: ruby = '' } = {}]) =>
               acc.import(
                 ruby
-                  ? new List([new Data(text), new Data(html('rp', '(')), new Data(html('rt', ruby)), new Data(html('rp', ')'))])
-                  : new List([new Data(text), new Data(html('rt'))]))
-            , new List<Data<string | HTMLElement>>()))))),
+                  ? new List([new Node(text), new Node(html('rp', '(')), new Node(html('rt', ruby)), new Node(html('rp', ')'))])
+                  : new List([new Node(text), new Node(html('rt'))]))
+            , new List<Node<string | HTMLElement>>()))))),
         ]);
       default:
         assert(rubies.length > 0);
         return new List([
-          new Data(html('ruby', defrag(unwrap(new List<Data<string | HTMLElement>>([
-            new Data(texts.foldr(({ value }, acc) => value + ' ' + acc, '').slice(0, -1)),
-            new Data(html('rp', '(')),
-            new Data(html('rt', rubies.foldr(({ value }, acc) => value + ' ' + acc, '').trim())),
-            new Data(html('rp', ')')),
+          new Node(html('ruby', defrag(unwrap(new List<Node<string | HTMLElement>>([
+            new Node(texts.foldr(({ value }, acc) => value + ' ' + acc, '').slice(0, -1)),
+            new Node(html('rp', '(')),
+            new Node(html('rt', rubies.foldr(({ value }, acc) => value + ' ' + acc, '').trim())),
+            new Node(html('rp', ')')),
           ]))))),
         ]);
     }
@@ -67,7 +67,7 @@ const delimiter = /[$"`\[\](){}<>（）［］｛｝|]|\\?\n/y;
 const text: RubyParser.TextParser = input => {
   const { context } = input;
   const { source } = context;
-  const acc = new List([new Data('')]);
+  const acc = new List([new Node('')]);
   let state = false;
   context.sequential = true;
   for (let { position } = context; position < source.length; position = context.position) {
@@ -86,7 +86,7 @@ const text: RubyParser.TextParser = input => {
       default: {
         if (source[position].trimStart() === '') {
           state ||= acc.last!.value.trimStart() !== '';
-          acc.push(new Data(''));
+          acc.push(new Node(''));
           context.position += 1;
           continue;
         }

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

@@ -1,25 +1,25 @@
 import { shortmedia } from './shortmedia';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/shortmedia', () => {
   describe('shortmedia', () => {
-    const parser = (source: string) => some(shortmedia)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(shortmedia);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('!http'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('!ttp'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('!http://'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('!Http://host'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' !http://host'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!http', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!ttp', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!http://', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('!Http://host', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' !http://host', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('!http://host'), ctx), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('!https://host'), ctx), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host', new Context())), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!https://host', new Context())), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a>'], '']);
     });
 
   });

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

@@ -1,55 +1,55 @@
 import { strong } from './strong';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/strong', () => {
   describe('strong', () => {
-    const parser = (source: string) => some(strong)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(strong);
 
     it('invalid', () => {
-      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), [['**', 'a', ' ', '**'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\n**'), ctx), [['**', 'a', '<br>', '**'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\\ **'), ctx), [['**', 'a', ' ', '**'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\\\n**'), ctx), [['**', 'a', '<br>', '**'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*'), ctx), [['**', 'a'], '*']);
-      assert.deepStrictEqual(inspect(parser('**a*b**'), ctx), [['**', 'a', '<em>b</em>'], '*']);
-      assert.deepStrictEqual(inspect(parser('** **'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('** a**'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('** a **'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('**\n**'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('**\na**'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('**\\ a**'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('**\\\na**'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('**<wbr>a**'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('***a***'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' **a**'), ctx), 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())), [['**', 'a', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a\n**', new Context())), [['**', 'a', '<br>', '**'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a\\ **', new Context())), [['**', 'a', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a\\\n**', new Context())), [['**', 'a', '<br>', '**'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a*', new Context())), [['**', 'a'], '*']);
+      assert.deepStrictEqual(inspect(parser, input('**a*b**', new Context())), [['**', 'a', '<em>b</em>'], '*']);
+      assert.deepStrictEqual(inspect(parser, input('** **', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('** a**', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('** a **', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('**\n**', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('**\na**', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('**\\ a**', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('**\\\na**', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('**<wbr>a**', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('***a***', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' **a**', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('**a**'), ctx), [['<strong>a</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**ab**'), ctx), [['<strong>ab</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\nb**'), ctx), [['<strong>a<br>b</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\\\nb**'), ctx), [['<strong>a<br>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a**', new Context())), [['<strong>a</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**ab**', new Context())), [['<strong>ab</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a\nb**', new Context())), [['<strong>a<br>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a\\\nb**', new Context())), [['<strong>a<br>b</strong>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('**a *b***'), ctx), [['<strong>a <em>b</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**- *b***'), ctx), [['<strong>- <em>b</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a **b****'), ctx), [['<strong>a <strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a&Tab;**b****'), ctx), [['<strong>a\t<strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a<wbr>**b****'), ctx), [['<strong>a<wbr><strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b*'), ctx), [['**', 'a', '<em>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b*c'), ctx), [['**', 'a', '<em>b</em>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b*c**'), ctx), [['<strong>a<em>b</em>c</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b*c**d'), ctx), [['<strong>a<em>b</em>c</strong>'], 'd']);
-      assert.deepStrictEqual(inspect(parser('**`a`**'), ctx), [['<strong><code data-src="`a`">a</code></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**(*a*)**'), ctx), [['<strong><span class="paren">(<em>a</em>)</span></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**(**a**)**'), ctx), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a *b***', new Context())), [['<strong>a <em>b</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**- *b***', new Context())), [['<strong>- <em>b</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a **b****', new Context())), [['<strong>a <strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a&Tab;**b****', new Context())), [['<strong>a\t<strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a<wbr>**b****', new Context())), [['<strong>a<wbr><strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a*b*', new Context())), [['**', 'a', '<em>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a*b*c', new Context())), [['**', 'a', '<em>b</em>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a*b*c**', new Context())), [['<strong>a<em>b</em>c</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a*b*c**d', new Context())), [['<strong>a<em>b</em>c</strong>'], 'd']);
+      assert.deepStrictEqual(inspect(parser, input('**`a`**', new Context())), [['<strong><code data-src="`a`">a</code></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**(*a*)**', new Context())), [['<strong><span class="paren">(<em>a</em>)</span></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**(**a**)**', new Context())), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
     });
 
   });

package/src/parser/inline/strong.ts

@@ -1,6 +1,6 @@
 import { StrongParser } from '../inline';
 import { Recursion } 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 { emphasis } from './emphasis';
@@ -19,5 +19,5 @@ export const strong: StrongParser = lazy(() => surround(
   ]))))),
   str('**'),
   false, [],
-  ([, bs]) => new List([new Data(html('strong', defrag(unwrap(bs))))]),
-  ([as, bs]) => bs && as.import(bs as List<Data<string>>)));
+  ([, bs]) => new List([new Node(html('strong', defrag(unwrap(bs))))]),
+  ([as, bs]) => bs && as.import(bs as List<Node<string>>)));

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

@@ -1,41 +1,41 @@
 import { template } from './template';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/template', () => {
   describe('template', () => {
-    const parser = (source: string) => some(template)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(template);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('{'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('{}'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('{{'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('{{\\}}'), ctx), [['<span class="invalid">{{\\}</span>'], '}']);
-      assert.deepStrictEqual(inspect(parser('{{a}b}'), ctx), [['<span class="invalid">{{a</span>'], '}b}']);
-      assert.deepStrictEqual(inspect(parser('{{{a}}'), ctx), [['<span class="invalid">{{{a}</span>'], '}']);
-      assert.deepStrictEqual(inspect(parser(' {{}}'), 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('{{', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('{{\\}}', new Context())), [['<span class="invalid">{{\\}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser, input('{{a}b}', new Context())), [['<span class="invalid">{{a</span>'], '}b}']);
+      assert.deepStrictEqual(inspect(parser, input('{{{a}}', new Context())), [['<span class="invalid">{{{a}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser, input(' {{}}', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('{{}}'), ctx), [['<span class="template">{{}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{}}}'), ctx), [['<span class="template">{{}}</span>'], '}']);
-      assert.deepStrictEqual(inspect(parser('{{ }}'), ctx), [['<span class="template">{{ }}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{ a }}'), ctx), [['<span class="template">{{ a }}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{\n}}'), ctx), [['<span class="template">{{<br>}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{\\\n}}'), ctx), [['<span class="template">{{\\<br>}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{a}}'), ctx), [['<span class="template">{{a}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{a b}}'), ctx), [['<span class="template">{{a b}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{\\}}}'), ctx), [['<span class="template">{{\\}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{<a>}}'), ctx), [['<span class="template">{{&lt;a&gt;}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{}}', new Context())), [['<span class="template">{{}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{}}}', new Context())), [['<span class="template">{{}}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser, input('{{ }}', new Context())), [['<span class="template">{{ }}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{ a }}', new Context())), [['<span class="template">{{ a }}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{\n}}', new Context())), [['<span class="template">{{<br>}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{\\\n}}', new Context())), [['<span class="template">{{\\<br>}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{a}}', new Context())), [['<span class="template">{{a}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{a b}}', new Context())), [['<span class="template">{{a b}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{\\}}}', new Context())), [['<span class="template">{{\\}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{<a>}}', new Context())), [['<span class="template">{{&lt;a&gt;}}</span>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('{{`a`}}'), ctx), [['<span class="template">{{`a`}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{{a}}}'), ctx), [['<span class="template">{{{a}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{{{a}}}}'), ctx), [['<span class="template">{{{{a}}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{`a`}}', new Context())), [['<span class="template">{{`a`}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{{a}}}', new Context())), [['<span class="template">{{{a}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('{{{{a}}}}', new Context())), [['<span class="template">{{{{a}}}}</span>'], '']);
     });
 
   });

package/src/parser/inline/template.ts

@@ -1,6 +1,6 @@
 import { TemplateParser } from '../inline';
 import { Recursion, Backtrack } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { unwrap, invalid } from '../util';
@@ -13,16 +13,16 @@ export const template: TemplateParser = lazy(() => surround(
   str('}}'),
   true, [],
   ([as, bs = new List(), cs]) => new List([
-    new Data(html('span', { class: 'template' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))
+    new Node(html('span', { class: 'template' }, defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))))
   ]),
   ([, bs], context) =>
     bs && new List([
-      new Data(html('span',
+      new Node(html('span',
         {
           class: 'invalid',
           ...invalid('template', 'syntax', `Missing the closing symbol "}}"`),
         },
-        context.source.slice(context.position - context.range!, context.position)))
+        context.source.slice(context.position - context.range, context.position)))
     ])));
 
 const bracket: TemplateParser.BracketParser = lazy(() => union([
@@ -39,5 +39,5 @@ const bracket: TemplateParser.BracketParser = lazy(() => union([
     true,
     [3 | Backtrack.escapable],
     undefined,
-    ([as, bs]) => bs && as.import(bs as List<Data<string>>)),
+    ([as, bs]) => bs && as.import(bs as List<Node<string>>)),
 ]));