securemark 0.295.0 → 0.295.2

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

@@ -1,53 +1,53 @@
 import { htmlentity } from './htmlentity';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/htmlentity', () => {
   describe('htmlentity', () => {
-    const parser = (source: string) => some(htmlentity)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(htmlentity);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('&'), ctx), [['&'], '']);
-      assert.deepStrictEqual(inspect(parser('&amp'), ctx), [['&amp'], '']);
-      assert.deepStrictEqual(inspect(parser('&;'), ctx), [['&'], ';']);
-      assert.deepStrictEqual(inspect(parser('& ;'), ctx), [['&'], ' ;']);
-      assert.deepStrictEqual(inspect(parser('&\n;'), ctx), [['&'], '\n;']);
-      assert.deepStrictEqual(inspect(parser('&a;'), ctx), [['<span class="invalid">&amp;a;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('&#;'), ctx), [['&'], '#;']);
-      assert.deepStrictEqual(inspect(parser('&#g;'), ctx), [['&'], '#g;']);
-      assert.deepStrictEqual(inspect(parser('&#x;'), ctx), [['&'], '#x;']);
-      assert.deepStrictEqual(inspect(parser('&#-1;'), ctx), [['&'], '#-1;']);
-      assert.deepStrictEqual(inspect(parser('&&amp;;'), ctx), [['&', '&'], ';']);
-      assert.deepStrictEqual(inspect(parser('&*&amp*'), ctx), [['&'], '*&amp*']);
-      assert.deepStrictEqual(inspect(parser('&<;'), ctx), [['&'], '<;']);
-      assert.deepStrictEqual(inspect(parser('&<>;'), ctx), [['&'], '<>;']);
-      assert.deepStrictEqual(inspect(parser('&>;'), ctx), [['&'], '>;']);
-      assert.deepStrictEqual(inspect(parser('&#35;'), ctx), [['&'], '#35;']);
-      assert.deepStrictEqual(inspect(parser('&#1234;'), ctx), [['&'], '#1234;']);
-      assert.deepStrictEqual(inspect(parser('&#992;'), ctx), [['&'], '#992;']);
-      assert.deepStrictEqual(inspect(parser('&#98765432;'), ctx), [['&'], '#98765432;']);
-      assert.deepStrictEqual(inspect(parser('&#0;'), ctx), [['&'], '#0;']);
-      assert.deepStrictEqual(inspect(parser('&#X22;'), ctx), [['&'], '#X22;']);
-      assert.deepStrictEqual(inspect(parser('&#XD06;'), ctx), [['&'], '#XD06;']);
-      assert.deepStrictEqual(inspect(parser('&#xcab;'), ctx), [['&'], '#xcab;']);
-      assert.deepStrictEqual(inspect(parser(' &amp;'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('&', new Context())), [['&'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&amp', new Context())), [['&amp'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&;', new Context())), [['&'], ';']);
+      assert.deepStrictEqual(inspect(parser, input('& ;', new Context())), [['&'], ' ;']);
+      assert.deepStrictEqual(inspect(parser, input('&\n;', new Context())), [['&'], '\n;']);
+      assert.deepStrictEqual(inspect(parser, input('&a;', new Context())), [['<span class="invalid">&amp;a;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&#;', new Context())), [['&'], '#;']);
+      assert.deepStrictEqual(inspect(parser, input('&#g;', new Context())), [['&'], '#g;']);
+      assert.deepStrictEqual(inspect(parser, input('&#x;', new Context())), [['&'], '#x;']);
+      assert.deepStrictEqual(inspect(parser, input('&#-1;', new Context())), [['&'], '#-1;']);
+      assert.deepStrictEqual(inspect(parser, input('&&amp;;', new Context())), [['&', '&'], ';']);
+      assert.deepStrictEqual(inspect(parser, input('&*&amp*', new Context())), [['&'], '*&amp*']);
+      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('&#35;', new Context())), [['&'], '#35;']);
+      assert.deepStrictEqual(inspect(parser, input('&#1234;', new Context())), [['&'], '#1234;']);
+      assert.deepStrictEqual(inspect(parser, input('&#992;', new Context())), [['&'], '#992;']);
+      assert.deepStrictEqual(inspect(parser, input('&#98765432;', new Context())), [['&'], '#98765432;']);
+      assert.deepStrictEqual(inspect(parser, input('&#0;', new Context())), [['&'], '#0;']);
+      assert.deepStrictEqual(inspect(parser, input('&#X22;', new Context())), [['&'], '#X22;']);
+      assert.deepStrictEqual(inspect(parser, input('&#XD06;', new Context())), [['&'], '#XD06;']);
+      assert.deepStrictEqual(inspect(parser, input('&#xcab;', new Context())), [['&'], '#xcab;']);
+      assert.deepStrictEqual(inspect(parser, input(' &amp;', new Context())), undefined);
     });
 
     it('entity', () => {
-      assert.deepStrictEqual(inspect(parser('&NewLine;'), ctx), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('&nbsp;'), ctx), [['\u00A0'], '']);
-      assert.deepStrictEqual(inspect(parser('&amp;'), ctx), [['&'], '']);
-      assert.deepStrictEqual(inspect(parser('&copy;'), ctx), [['©'], '']);
-      assert.deepStrictEqual(inspect(parser('&AElig;'), ctx), [['Æ'], '']);
-      assert.deepStrictEqual(inspect(parser('&Dcaron;'), ctx), [['Ď'], '']);
-      assert.deepStrictEqual(inspect(parser('&frac34;'), ctx), [['¾'], '']);
-      assert.deepStrictEqual(inspect(parser('&HilbertSpace;'), ctx), [['ℋ'], '']);
-      assert.deepStrictEqual(inspect(parser('&DifferentialD;'), ctx), [['ⅆ'], '']);
-      assert.deepStrictEqual(inspect(parser('&ClockwiseContourIntegral;'), ctx), [['∲'], '']);
-      assert.deepStrictEqual(inspect(parser('&ngE;'), ctx), [['≧̸'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&NewLine;', new Context())), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('&nbsp;', new Context())), [['\u00A0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&amp;', new Context())), [['&'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&copy;', new Context())), [['©'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&AElig;', new Context())), [['Æ'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&Dcaron;', new Context())), [['Ď'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&frac34;', new Context())), [['¾'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&HilbertSpace;', new Context())), [['ℋ'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&DifferentialD;', new Context())), [['ⅆ'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&ClockwiseContourIntegral;', new Context())), [['∲'], '']);
+      assert.deepStrictEqual(inspect(parser, input('&ngE;', new Context())), [['≧̸'], '']);
     });
 
   });

package/src/parser/inline/htmlentity.ts

@@ -1,6 +1,6 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { Backtrack } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, surround, fmap } from '../../combinator';
 import { str } from '../source';
 import { invalid } from '../util';
@@ -11,16 +11,16 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = surround(
   false,
   [3 | Backtrack.unescapable],
   ([as, bs, cs]) =>
-    new List([new Data(parser(as.head!.value + bs.head!.value + cs.head!.value))]),
+    new List([new Node(parser(as.head!.value + bs.head!.value + cs.head!.value))]),
   ([as, bs]) =>
-    new List([new Data(as.head!.value + (bs?.head?.value ?? ''))]));
+    new List([new Node(as.head!.value + (bs?.head?.value ?? ''))]));
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
   ([{ value }]) => new List([
     length === 1 || value.at(-1) !== ';'
-      ? new Data(value)
-      : new Data(html('span', {
+      ? new Node(value)
+      : new Node(html('span', {
           class: 'invalid',
           ...invalid('htmlentity', 'syntax', 'Invalid HTML entity'),
         }, value))

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

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

package/src/parser/inline/insertion.ts

@@ -1,6 +1,6 @@
 import { InsertionParser } 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 insertion: InsertionParser = 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('ins', 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('ins', defrag(unwrap(nodes))))]))));

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

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

package/src/parser/inline/italic.ts

@@ -1,6 +1,6 @@
 import { ItalicParser } 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 { tightStart, blankWith } from '../visibility';
@@ -20,6 +20,6 @@ export const italic: ItalicParser = 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('i', 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('i', defrag(unwrap(nodes))))]))));