securemark 0.295.0 → 0.295.2

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

@@ -1,130 +1,130 @@
 import { reference } from './reference';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/reference', () => {
   describe('reference', () => {
-    const parser = (source: string) => some(reference)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(reference);
 
     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), undefined);
-      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), 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('[[\\\na]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a\n]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a\\\n]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a\nb]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a\\\nb]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[\\]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a]b]]'), 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('[', 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())), 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('[[ [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('[[\\\na]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a\n]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a\\\n]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a\nb]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a\\\nb]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[*a\nb*]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[\\]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[a]b]]', 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), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[ a ]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[\\ a]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[<wbr>a]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[a]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[a ]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[a  ]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[a &nbsp;]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[a <wbr>]]'), ctx), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[ab]]'), ctx), [['<sup class="reference"><span>ab</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[ a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[ a ]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[\\ a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[<wbr>a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[a ]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[a  ]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[a &nbsp;]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[a <wbr>]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[ab]]', new Context())), [['<sup class="reference"><span>ab</span></sup>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('[[`a`]]'), ctx), [['<sup class="reference"><span><code data-src="`a`">a</code></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[@a]]'), ctx), [['<sup class="reference"><span><a class="account" href="/@a">@a</a></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[http://host]]'), ctx), [['<sup class="reference"><span><a class="url" href="http://host" target="_blank">http://host</a></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[![]{a}]]'), ctx), [['<sup class="reference"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[a]]]'), ctx), [['<sup class="reference"><span>[a]</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[a]]]]'), ctx), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[((a))]]'), ctx), [['<sup class="reference"><span><span class="paren">((a))</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[`a`]]', new Context())), [['<sup class="reference"><span><code data-src="`a`">a</code></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[@a]]', new Context())), [['<sup class="reference"><span><a class="account" href="/@a">@a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[http://host]]', new Context())), [['<sup class="reference"><span><a class="url" href="http://host" target="_blank">http://host</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[![]{a}]]', new Context())), [['<sup class="reference"><span>!<a class="url" href="a">a</a></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[[a]]]', new Context())), [['<sup class="reference"><span>[a]</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[[[a]]]]', new Context())), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[((a))]]', new Context())), [['<sup class="reference"><span><span class="paren">((a))</span></span></sup>'], '']);
     });
 
     it('abbr', () => {
-      assert.deepStrictEqual(inspect(parser('[[^]]'), ctx), [['<sup class="invalid"><span>^</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A,]]'), ctx), [['<sup class="reference" data-abbr="A,"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A, ]]'), ctx), [['<sup class="reference" data-abbr="A,"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A.]]'), ctx), [['<sup class="reference" data-abbr="A."><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A.,]]'), ctx), [['<sup class="reference" data-abbr="A.,"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A?]]'), ctx), [['<sup class="reference" data-abbr="A?"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A?,]]'), ctx), [['<sup class="reference" data-abbr="A?,"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A ]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A  ]]'), ctx), [['<sup class="invalid"><span>^A</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A B]]'), ctx), [['<sup class="reference" data-abbr="A B"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A  B]]'), ctx), [['<sup class="invalid"><span>^A B</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A,|]]'), ctx), [['<sup class="reference" data-abbr="A,"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A |]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|b ]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|b  ]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A| ]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A| b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|  ]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[^A|<wbr>]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[^A|<wbr>b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|^]]'), ctx), [['<sup class="reference" data-abbr="A"><span>^</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|^B]]'), ctx), [['<sup class="reference" data-abbr="A"><span>^B</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1]]'), ctx), [['<sup class="invalid"><span>^1</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1A]]'), ctx), [['<sup class="invalid"><span>^1A</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1 ]]'), ctx), [['<sup class="invalid"><span>^1</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1 A]]'), ctx), [['<sup class="invalid"><span>^1 A</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1|]]'), ctx), [['<sup class="invalid"><span>^1|</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1 |]]'), ctx), [['<sup class="invalid"><span>^1 |</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Abc]]'), ctx), [['<sup class="reference" data-abbr="Abc"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A, B]]'), ctx), [['<sup class="reference" data-abbr="A, B"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser(`[[^A's, Aces']]`), ctx), [[`<sup class="reference" data-abbr="A's, Aces'"><span></span></sup>`], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1, 2]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1, 2"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1, fig. 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1, fig. 1.1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1.1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1, fig. 1.1-2.1b]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1.1-2.1b"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1, fig. 1.1a-b]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1.1a-b"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1-2]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1-2"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1:1-2]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1:1-2"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1n]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1n"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1n1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1n1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, 1nn1-2]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, 1nn1-2"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, i]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, i"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, capter 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, capter 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020, cap. 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020, cap. 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020a]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020a"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020a, 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020a, 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020-2021a]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020-2021a"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz 2020-2021a, 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz 2020-2021a, 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz, April 1, 2020]]'), ctx), [['<sup class="reference" data-abbr="Xyz, April 1, 2020"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz, April 1, 2020, 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz, April 1, 2020, 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz n.d.]]'), ctx), [['<sup class="reference" data-abbr="Xyz n.d."><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^Xyz n.d., 1]]'), ctx), [['<sup class="reference" data-abbr="Xyz n.d., 1"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^X. Y., and Z et al. 2020, 1-2]]'), ctx), [['<sup class="reference" data-abbr="X. Y., and Z et al. 2020, 1-2"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^^]]'), ctx), [['<sup class="invalid"><span>^^</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[\\^]]'), ctx), [['<sup class="reference"><span>^</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ ]]'), ctx), [['<sup class="invalid"><span>^</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ A]]'), ctx), [['<sup class="invalid"><span>^ A</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ |]]'), ctx), [['<sup class="invalid"><span>^ |</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ |b]]'), ctx), [['<sup class="invalid"><span>^ |b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ | ]]'), ctx), [['<sup class="invalid"><span>^ |</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ | b]]'), ctx), [['<sup class="invalid"><span>^ | b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^]]', new Context())), [['<sup class="invalid"><span>^</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A]]', new Context())), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A,]]', new Context())), [['<sup class="reference" data-abbr="A,"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A, ]]', new Context())), [['<sup class="reference" data-abbr="A,"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A.]]', new Context())), [['<sup class="reference" data-abbr="A."><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A.,]]', new Context())), [['<sup class="reference" data-abbr="A.,"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A?]]', new Context())), [['<sup class="reference" data-abbr="A?"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A?,]]', new Context())), [['<sup class="reference" data-abbr="A?,"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A ]]', new Context())), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A  ]]', new Context())), [['<sup class="invalid"><span>^A</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A B]]', new Context())), [['<sup class="reference" data-abbr="A B"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A  B]]', new Context())), [['<sup class="invalid"><span>^A B</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|]]', new Context())), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A,|]]', new Context())), [['<sup class="reference" data-abbr="A,"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A |]]', new Context())), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|b]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|b]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|b ]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|b  ]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A| ]]', new Context())), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A| b]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|  ]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|<wbr>]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|<wbr>b]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|^]]', new Context())), [['<sup class="reference" data-abbr="A"><span>^</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|^B]]', new Context())), [['<sup class="reference" data-abbr="A"><span>^B</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^1]]', new Context())), [['<sup class="invalid"><span>^1</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^1A]]', new Context())), [['<sup class="invalid"><span>^1A</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^1 ]]', new Context())), [['<sup class="invalid"><span>^1</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^1 A]]', new Context())), [['<sup class="invalid"><span>^1 A</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^1|]]', new Context())), [['<sup class="invalid"><span>^1|</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^1 |]]', new Context())), [['<sup class="invalid"><span>^1 |</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Abc]]', new Context())), [['<sup class="reference" data-abbr="Abc"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A, B]]', new Context())), [['<sup class="reference" data-abbr="A, B"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`[[^A's, Aces']]`, new Context())), [[`<sup class="reference" data-abbr="A's, Aces'"><span></span></sup>`], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1, 2]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1, 2"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1, fig. 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1, fig. 1.1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1.1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1, fig. 1.1-2.1b]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1.1-2.1b"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1, fig. 1.1a-b]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1, fig. 1.1a-b"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1-2]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1-2"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1:1-2]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1:1-2"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1n]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1n"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1n1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1n1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, 1nn1-2]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, 1nn1-2"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, i]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, i"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, capter 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, capter 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020, cap. 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020, cap. 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020a]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020a"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020a, 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020a, 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020-2021a]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020-2021a"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz 2020-2021a, 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz 2020-2021a, 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz, April 1, 2020]]', new Context())), [['<sup class="reference" data-abbr="Xyz, April 1, 2020"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz, April 1, 2020, 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz, April 1, 2020, 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz n.d.]]', new Context())), [['<sup class="reference" data-abbr="Xyz n.d."><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^Xyz n.d., 1]]', new Context())), [['<sup class="reference" data-abbr="Xyz n.d., 1"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^X. Y., and Z et al. 2020, 1-2]]', new Context())), [['<sup class="reference" data-abbr="X. Y., and Z et al. 2020, 1-2"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^^]]', new Context())), [['<sup class="invalid"><span>^^</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[\\^]]', new Context())), [['<sup class="reference"><span>^</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^ ]]', new Context())), [['<sup class="invalid"><span>^</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^ A]]', new Context())), [['<sup class="invalid"><span>^ A</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^ |]]', new Context())), [['<sup class="invalid"><span>^ |</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^ |b]]', new Context())), [['<sup class="invalid"><span>^ |b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^ | ]]', new Context())), [['<sup class="invalid"><span>^ |</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^ | b]]', new Context())), [['<sup class="invalid"><span>^ | b</span></sup>'], '']);
     });
 
   });

package/src/parser/inline/reference.ts

@@ -1,6 +1,6 @@
 import { ReferenceParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, subsequence, some, precedence, state, constraint, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
@@ -18,75 +18,36 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   ]))),
   ']]',
   false,
-  [1 | Backtrack.common, 3 | Backtrack.doublebracket],
+  [2, 1 | Backtrack.common, 3 | Backtrack.doublebracket],
   ([, ns], context) => {
-    const { position, range = 0, linebreak = 0 } = context;
+    const { position, range, linebreak } = context;
     if (linebreak === 0) {
-      return new List([new Data(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
+      return new List([new Node(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
     }
     else {
       const head = position - range;
       setBacktrack(context, 2 | Backtrack.link, head, 2);
     }
   },
-  ([as, bs], context) => {
-    if (!bs) return;
-    const { source, position, range = 0, linebreak = 0, state = 0 } = context;
+  (_, context): undefined => {
+    const { source, position, range, linebreak } = context;
     const head = position - range;
     if (source[position] !== ']') {
       setBacktrack(context, 2 | Backtrack.common, head, 2);
     }
     else if (linebreak !== 0) {
-      setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head, 2);
+      setBacktrack(context, 2 | Backtrack.doublebracket | Backtrack.link | Backtrack.ruby, head, 2);
     }
     else {
       assert(source[position] === ']');
-      if (state & State.annotation) {
-        bs.push(new Data(source[position]));
-      }
       context.position += 1;
-      let result: ReturnType<typeof textlink>;
-      if (source[context.position] !== '{') {
+      if (source[context.position] !== '{' ||
+          isBacktrack(context, 1 | Backtrack.link) ||
+          !textlink({ context })) {
         setBacktrack(context, 2 | Backtrack.link, head + 1);
-        result = new List();
-      }
-      else {
-        result = !isBacktrack(context, 1 | Backtrack.link)
-          ? textlink({ context })
-          : undefined;
-        context.range = range;
-        if (!result) {
-          setBacktrack(context, 2 | Backtrack.link, head + 1);
-          result = new List();
-        }
-      }
-      assert(result);
-      if (context.position === source.length) {
-        setBacktrack(context, 2 | Backtrack.link, head);
-      }
-      else {
-        assert(state ^ State.link);
-        const next = surround(
-          '',
-          some(inline, ']', [[']', 1]]),
-          str(']'),
-          true, [],
-          ([, cs = new List(), ds]) =>
-            cs.import(ds),
-          ([, cs = new List()]) => {
-            setBacktrack(context, 2 | Backtrack.link, head);
-            return cs;
-          })
-          ({ context });
-        if (state & State.annotation && next) {
-          return (as as List<Data<string | HTMLElement>>).import(bs).import(result).import(next);
-        }
       }
       context.position = position;
     }
-    return state & State.annotation
-      ? as.import(bs as List<Data<string>>)
-      : undefined;
   })));
 
 // Chicago-Style
@@ -96,17 +57,17 @@ const abbr: ReferenceParser.AbbrParser = surround(
   /\|?(?=]])|\|/y,
   true, [],
   ([, ns], context) => {
-    const { source, position, range = 0 } = context;
-    if (!ns) return new List([new Data(''), new Data(source.slice(position - range, source[position - 1] === '|' ? position - 1 : position))]);
+    const { source, position, range } = context;
+    if (!ns) return new List([new Node(''), new Node(source.slice(position - range, source[position - 1] === '|' ? position - 1 : position))]);
     context.position += source[position] === ' ' ? 1 : 0;
-    return new List([new Data(Command.Separator), new Data(ns.head!.value.trimEnd())]);
+    return new List([new Node(Command.Separator), new Node(ns.head!.value.trimEnd())]);
   },
   (_, context) => {
-    context.position -= context.range!;
-    return new List([new Data('')]);
+    context.position -= context.range;
+    return new List([new Node('')]);
   });
 
-function attributes(ns: List<Data<string | HTMLElement>>): Record<string, string | undefined> {
+function attributes(ns: List<Node<string | HTMLElement>>): Record<string, string | undefined> {
   switch (ns.head!.value) {
     case '':
       return { class: 'invalid', ...invalid('reference', 'syntax', 'Invalid abbreviation') };

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

@@ -1,65 +1,65 @@
 import { remark } from './remark';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/remark', () => {
   describe('remark', () => {
-    const parser = (source: string) => some(remark)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(remark);
 
     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('[%a%]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[%a b%]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[% '), ctx), [['[%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% \n a'), ctx), [['[%', '<br>', ' a'], '']);
-      assert.deepStrictEqual(inspect(parser('[%%]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[% [%'), ctx), [['[%', ' ', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [% '), ctx), [['[%', ' ', '[%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [% a'), ctx), [['[%', ' ', '[%', ' a'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [% a %]'), ctx), [['[%', ' ', '<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      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 [% b'), ctx), [['[%', ' a ', '[%', ' b'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [%% b'), ctx), [['[%', ' a ', '<span class="invalid">[%%</span>', ' b'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% a [% b'), ctx), [['<span class="invalid">[%%</span>'], ' a [% b']);
-      assert.deepStrictEqual(inspect(parser('[%\\ a %]'), 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('[% [%% %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">[%%</span> %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% [% %%]'), ctx), [['<span class="invalid">[%%</span>'], ' [% %%]']);
-      assert.deepStrictEqual(inspect(parser('[%% a %]'), ctx), [['<span class="invalid">[%%</span>'], ' 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('[%[%', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[%a%]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[%a b%]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[% ', new Context())), [['[%'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% \n a', new Context())), [['[%', '<br>', ' a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[%%]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[% [%', new Context())), [['[%', ' ', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% [% ', new Context())), [['[%', ' ', '[%'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% [% a', new Context())), [['[%', ' ', '[%', ' a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% [% a %]', new Context())), [['[%', ' ', '<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
+      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 [% b', new Context())), [['[%', ' a ', '[%', ' b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a [%% b', new Context())), [['[%', ' a ', '<span class="invalid">[%%</span>', ' b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[%% a [% b', new Context())), [['<span class="invalid">[%%</span>'], ' a [% b']);
+      assert.deepStrictEqual(inspect(parser, input('[%\\ a %]', 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('[% [%% %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">[%%</span> %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[%% [% %%]', new Context())), [['<span class="invalid">[%%</span>'], ' [% %%]']);
+      assert.deepStrictEqual(inspect(parser, input('[%% a %]', new Context())), [['<span class="invalid">[%%</span>'], ' a %]']);
+      assert.deepStrictEqual(inspect(parser, input(' [% a %]', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('[% %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%   %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% - %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% - %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%  a  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%  -  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% - %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a b %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a b %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a\nb %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a %] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], ' %]']);
-      assert.deepStrictEqual(inspect(parser('[% %%] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %%] %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [% a %] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="remark"><input type="checkbox"><span>[% a %]</span></span> %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a %]b'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], 'b']);
-      assert.deepStrictEqual(inspect(parser('[%\na\n%]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%<br>a<br>%]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% &a; %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">&amp;a;</span> %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% &copy; %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% © %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% &amp;copy; %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% &amp;copy; %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [ %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% [ %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% \\ a %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%  a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% $-a %]$'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <a class="label" data-label="$-a">$-a</a> %]</span></span>'], '$']);
-      assert.deepStrictEqual(inspect(parser('[% <bdi> %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">&lt;bdi&gt;</span> %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[%  %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[%   %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% - %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% - %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[%  a  %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[%  -  %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% - %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a b %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% a b %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a\nb %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a %] %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], ' %]']);
+      assert.deepStrictEqual(inspect(parser, input('[% %%] %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% %%] %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% [% a %] %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% <span class="remark"><input type="checkbox"><span>[% a %]</span></span> %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a %]b', new Context())), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('[%\na\n%]', new Context())), [['<span class="remark"><input type="checkbox"><span>[%<br>a<br>%]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% &a; %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">&amp;a;</span> %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% &copy; %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% © %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% &amp;copy; %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% &amp;copy; %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% [ %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% [ %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% \\ a %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[%  a %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% $-a %]$', new Context())), [['<span class="remark"><input type="checkbox"><span>[% <a class="label" data-label="$-a">$-a</a> %]</span></span>'], '$']);
+      assert.deepStrictEqual(inspect(parser, input('[% <bdi> %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">&lt;bdi&gt;</span> %]</span></span>'], '']);
     });
 
   });

package/src/parser/inline/remark.ts

@@ -1,6 +1,6 @@
 import { RemarkParser } 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, focus, surround, close, fallback, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
@@ -14,12 +14,12 @@ export const remark: RemarkParser = lazy(() => fallback(surround(
   close(text, str(`%]`)),
   true, [],
   ([as, bs = new List(), cs]) => new List([
-    new Data(html('span', { class: 'remark' }, [
+    new Node(html('span', { class: 'remark' }, [
       html('input', { type: 'checkbox' }),
-      html('span', defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))),
+      html('span', defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))),
     ])),
   ]),
-  ([as, bs]) => bs && as.import(bs as List<Data<string>>)),
+  ([as, bs]) => bs && as.import(bs as List<Node<string>>)),
   focus(/\[%+(?=[ \n])/y, ({ context: { source } }) => new List([
-    new Data(html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source))
+    new Node(html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source))
   ]))));