securemark 0.295.0 → 0.295.2

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

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

package/src/parser/inline/emphasis.ts

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

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

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

package/src/parser/inline/emstrong.ts

@@ -1,6 +1,6 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
-import { Result, List, Data, Node, Context, IntermediateParser } from '../../combinator/data/parser';
+import { Parser, Result, List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
@@ -10,12 +10,12 @@ import { tightStart, blankWith } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
+const substrong: Parser.IntermediateParser<StrongParser> = lazy(() => some(union([
   emphasis,
   some(inline, blankWith('*')),
   open(some(inline, '*'), inline),
 ])));
-const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
+const subemphasis: Parser.IntermediateParser<EmphasisParser> = lazy(() => some(union([
   strong,
   some(inline, blankWith('*')),
   open(some(inline, '*'), inline),
@@ -34,9 +34,9 @@ export const emstrong: EmStrongParser = lazy(() =>
     ])))),
     str(/\*{1,3}/y),
     false, [],
-    ([, bs, cs], context): Result<Node<EmStrongParser>, Context<EmStrongParser>> => {
+    ([, bs, cs], context): Result<Parser.Node<EmStrongParser>, Parser.Context<EmStrongParser>> => {
       assert(cs.length === 1);
-      const { buffer = new List() } = context;
+      const { buffer } = context;
       switch (cs.head!.value) {
         case '***':
           return bs;
@@ -47,18 +47,18 @@ export const emstrong: EmStrongParser = lazy(() =>
               const { source } = context;
               if (source.startsWith('*', context.position)) {
                 context.position += 1;
-                buffer.push(new Data(html('strong', defrag(unwrap(bs)))));
+                buffer.push(new Node(html('strong', defrag(unwrap(bs)))));
                 buffer.import(ds);
-                return new List([new Data(html('em', defrag(unwrap(buffer)))), new Data(Command.Separator)]);
+                return new List([new Node(html('em', defrag(unwrap(buffer)))), new Node(Command.Separator)]);
               }
               else {
-                buffer.push(new Data(html('strong', defrag(unwrap(bs)))));
+                buffer.push(new Node(html('strong', defrag(unwrap(bs)))));
                 buffer.import(ds);
-                buffer.push(new Data(Command.Separator));
+                buffer.push(new Node(Command.Separator));
                 return prepend('*', buffer);
               }
             })
-            ({ context }) ?? prepend('*', buffer.import(new List([new Data(html('strong', defrag(unwrap(bs)))), new Data(Command.Separator)])));
+            ({ context }) ?? prepend('*', buffer.import(new List([new Node(html('strong', defrag(unwrap(bs)))), new Node(Command.Separator)])));
         case '*':
           return bind<StrongParser>(
             substrong,
@@ -66,24 +66,24 @@ export const emstrong: EmStrongParser = lazy(() =>
               const { source } = context;
               if (source.startsWith('**', context.position)) {
                 context.position += 2;
-                buffer.push(new Data(html('em', defrag(unwrap(bs)))));
+                buffer.push(new Node(html('em', defrag(unwrap(bs)))));
                 buffer.import(ds);
-                return new List([new Data(html('strong', defrag(unwrap(buffer)))), new Data(Command.Separator)]);
+                return new List([new Node(html('strong', defrag(unwrap(buffer)))), new Node(Command.Separator)]);
               }
               else {
-                buffer.push(new Data(html('em', defrag(unwrap(bs)))));
+                buffer.push(new Node(html('em', defrag(unwrap(bs)))));
                 buffer.import(ds);
-                buffer.push(new Data(Command.Separator));
+                buffer.push(new Node(Command.Separator));
                 return prepend('**', buffer);
               }
             })
-            ({ context }) ?? prepend('**', buffer.import(new List([new Data(html('em', defrag(unwrap(bs)))), new Data(Command.Separator)])));
+            ({ context }) ?? prepend('**', buffer.import(new List([new Node(html('em', defrag(unwrap(bs)))), new Node(Command.Separator)])));
       }
       assert(false);
     },
-    ([, bs], { buffer }) => bs && buffer!.import(bs) && buffer!.push(new Data(Command.Cancel)) && buffer!),
+    ([, bs], { buffer }) => bs && buffer.import(bs) && buffer.push(new Node(Command.Cancel)) && buffer),
     // 3以上の`*`に対してemの適用を保証する
-    nodes => new List([new Data(html('em', [html('strong', defrag(unwrap(nodes)))]))]),
+    nodes => new List([new Node(html('em', [html('strong', defrag(unwrap(nodes)))]))]),
     (nodes, context, prefix, postfix, state) => {
       context.position += postfix;
       assert(postfix < 3);
@@ -92,10 +92,10 @@ export const emstrong: EmStrongParser = lazy(() =>
           case 0:
             break;
           case 1:
-            nodes = new List([new Data(html('em', defrag(unwrap(nodes))))]);
+            nodes = new List([new Node(html('em', defrag(unwrap(nodes))))]);
             break;
           case 2:
-            nodes = new List([new Data(html('strong', defrag(unwrap(nodes))))]);
+            nodes = new List([new Node(html('strong', defrag(unwrap(nodes))))]);
             break;
           default:
             assert(false);
@@ -112,7 +112,7 @@ export const emstrong: EmStrongParser = lazy(() =>
                 const { source } = context;
                 if (source.startsWith('*', context.position)) {
                   context.position += 1;
-                  return new List([new Data(html('em', defrag(unwrap(nodes.import(ds)))))]);
+                  return new List([new Node(html('em', defrag(unwrap(nodes.import(ds)))))]);
                 }
                 else {
                   return prepend('*', nodes.import(ds));
@@ -128,7 +128,7 @@ export const emstrong: EmStrongParser = lazy(() =>
                 const { source } = context;
                 if (source.startsWith('**', context.position)) {
                   context.position += 2;
-                  return new List([new Data(html('strong', defrag(unwrap(nodes.import(ds)))))]);
+                  return new List([new Node(html('strong', defrag(unwrap(nodes.import(ds)))))]);
                 }
                 else {
                   return prepend('**', nodes.import(ds));
@@ -145,12 +145,12 @@ export const emstrong: EmStrongParser = lazy(() =>
       return nodes;
     })));
 
-function prepend<N>(prefix: string, nodes: List<Data<N>>): List<Data<N>> {
+function prepend<N>(prefix: string, nodes: List<Node<N>>): List<Node<N>> {
   if (typeof nodes.head?.value === 'string') {
     nodes.head.value = prefix + nodes.head.value as N;
   }
   else {
-    nodes.unshift(new Data(prefix as N));
+    nodes.unshift(new Node(prefix as N));
   }
   return nodes;
 }