securemark 0.299.3 → 0.300.0

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

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

package/src/parser/inline/reference.ts

@@ -1,7 +1,7 @@
 import { ReferenceParser } from '../inline';
-import { State, Backtrack, Command } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { union, subsequence, some, precedence, state, constraint, surround, open, isBacktrack, setBacktrack, lazy } from '../../combinator';
+import { Input, State, Backtrack, Command } from '../context';
+import { Result, List, Node } from '../../combinator/parser';
+import { union, subsequence, some, precedence, state, constraint, backtrack, surround, open, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
@@ -9,7 +9,7 @@ import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => constraint(State.reference, surround(
+export const reference: ReferenceParser = lazy(() => constraint(State.reference, backtrack(surround(
   '[[',
   precedence(1, state(State.annotation | State.reference,
   subsequence([
@@ -19,56 +19,85 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   ']]',
   false,
   [2, 1 | Backtrack.common, 3 | Backtrack.doublebracket],
-  ([, ns], context) => {
-    const { position, range, linebreak } = context;
+  ([, ns], input, output) => {
+    const { position, range, linebreak } = input;
     const head = position - range;
     if (linebreak !== 0) {
-      setBacktrack(context, 2 | Backtrack.link, head, 2);
+      setBacktrack(input, 2 | Backtrack.link, head, 2);
       return;
     }
-    return new List([new Node(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
+    return output.import(new List([
+      new Node(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))
+    ]));
   },
-  (_, context): undefined => {
-    const { source, position, range, linebreak } = context;
+  (_, input) => {
+    const { source, position, range, linebreak } = input;
     const head = position - range;
     if (source[position] !== ']') {
-      setBacktrack(context, 2 | Backtrack.common, head, 2);
+      setBacktrack(input, 2 | Backtrack.common, head, 2);
     }
     else if (linebreak !== 0) {
-      setBacktrack(context, 2 | Backtrack.doublebracket | Backtrack.link | Backtrack.ruby, head, 2);
+      setBacktrack(input, 2 | Backtrack.doublebracket | Backtrack.link | Backtrack.ruby, head, 2);
     }
     else if (source[position + 1] !== '{') {
-      setBacktrack(context, 2 | Backtrack.link, head + 1);
+      setBacktrack(input, 2 | Backtrack.link, head + 1);
     }
     else {
       assert(source[position] === ']');
-      assert(~context.state & State.link);
-      context.position += 1;
-      assert(!isBacktrack(context, 1 | Backtrack.link));
-      if (!textlink(context)) {
-        setBacktrack(context, 2 | Backtrack.link, head + 1);
-      }
-      context.position = position;
-      context.range = range;
+      assert(~input.state & State.link);
+      input.position += 1;
+      assert(!isBacktrack(input, 1 | Backtrack.link));
+      input.memory = {
+        position,
+        range,
+        head,
+      };
+      return cont;
     }
-  })));
+  }))));
+
+interface Memory {
+  readonly position: number;
+  readonly range: number;
+  readonly head: number;
+}
+const cont: Result<HTMLElement | string, Input<Memory>> = [
+  (_, output) => {
+    output.push();
+    return output.context;
+  },
+  lazy(() => textlink),
+  (input, output) => {
+    const { memory: { position, range, head } } = input;
+    if (output.state) {
+      setBacktrack(input, 2 | Backtrack.link, head + 1);
+    }
+    input.position = position;
+    input.range = range;
+    output.pop();
+    return Result.fail;
+  },
+];
 
 // Chicago-Style
-const abbr: ReferenceParser.AbbrParser = surround(
+const abbr: ReferenceParser.AbbrParser = backtrack(surround(
   str('^'),
   union([str(/(?=[A-Z])(?:[0-9A-Za-z]'?|(?:[-.:]|\.?\??,? ?)(?!['\-.:?, ]))+/y)]),
   /\|?(?=]])|\|/y,
   true, [],
-  ([, ns], context) => {
-    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 Node(Command.Separator), new Node(ns.head!.value.trimEnd())]);
+  ([, ns], input, output) => {
+    const { source, position, range } = input;
+    if (!ns) return output.import(new List([
+      new Node(''),
+      new Node(source.slice(position - range, source[position - 1] === '|' ? position - 1 : position)),
+    ]));
+    input.position += source[position] === ' ' ? 1 : 0;
+    return output.import(new List([new Node(Command.Separator), new Node(ns.head!.value.trimEnd())]));
   },
-  (_, context) => {
-    context.position -= context.range;
-    return new List([new Node('')]);
-  });
+  (_, input, output) => {
+    input.position -= input.range;
+    return output.append(new Node(''));
+  }));
 
 function attributes(ns: List<Node<string | HTMLElement>>): Record<string, string | undefined> {
   switch (ns.head!.value) {

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

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

package/src/parser/inline/remark.ts

@@ -1,25 +1,25 @@
 import { RemarkParser } from '../inline';
 import { Recursion } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, focus, surround, close, fallback, lazy } from '../../combinator';
+import { List, Node } from '../../combinator/parser';
+import { union, some, recursion, precedence, backtrack, focus, surround, close, fallback, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
 import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const remark: RemarkParser = lazy(() => fallback(surround(
+export const remark: RemarkParser = lazy(() => fallback(backtrack(surround(
   str(/\[%(?=[ \r\n])/y),
   precedence(3, recursion(Recursion.inline,
   some(union([inline]), /[ \n]%\]/y, [[/[ \n]%\]/y, 3]]))),
   close(text, str('%]')),
   true, [],
-  ([as, bs = new List(), cs]) => new List([
-    new Node(html('span', { class: 'remark' }, [
-      html('input', { type: 'checkbox' }),
-      html('span', defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))),
-    ])),
-  ]),
-  ([as, bs]) => bs && as.import(bs as List<Node<string>>)),
-  focus(/\[%+(?=[ \r\n])/y, ({ source }) => new List([
-    new Node(html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source))
-  ]))));
+  ([as, bs = new List(), cs], _, output) =>
+    output.append(
+      new Node(html('span', { class: 'remark' }, [
+        html('input', { type: 'checkbox' }),
+        html('span', defrag(unwrap(as.import(bs as List<Node<string>>).import(cs)))),
+      ]))),
+  ([as, bs = new List()], _, output) => output.import(as.import(bs as List<Node<string>>)))),
+  focus(/\[%+(?=[ \r\n])/y, ({ source }, output) =>
+    output.append(new Node(
+      html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source))))));