securemark 0.291.1 → 0.292.0

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

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

package/src/parser/inline/reference.ts

@@ -1,6 +1,6 @@
 import { ReferenceParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
-import { eval, exec } from '../../combinator/data/parser';
+import { eval } 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';
@@ -19,72 +19,73 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   ]))),
   ']]',
   false,
-  ([, ns], rest, context) => {
-    if (context.linebreak === 0) {
-      return [[html('sup', attributes(ns), [html('span', defrag(trimBlankNodeEnd(ns)))])], rest];
+  ([, ns], context) => {
+    const { position, range = 0, linebreak = 0 } = context;
+    if (linebreak === 0) {
+      return [[html('sup', attributes(ns), [html('span', defrag(trimBlankNodeEnd(ns)))])]];
     }
     else {
-      const head = context.recent!.reduce((a, b) => a + b.length, rest.length);
+      const head = position - range;
       setBacktrack(context, [2 | Backtrack.link], head, 2);
     }
   },
-  ([as, bs], rest, context) => {
-    const { recent } = context;
-    const head = recent!.reduce((a, b) => a + b.length, rest.length);
-    if (rest[0] !== ']') {
+  ([as, bs], context) => {
+    if (!bs) return;
+    const { source, position, range = 0, linebreak = 0, state = 0 } = context;
+    const head = position - range;
+    if (source[position] !== ']') {
       setBacktrack(context, [2 | Backtrack.bracket], head, 2);
     }
-    else if (context.linebreak! > 0) {
+    else if (linebreak !== 0) {
       setBacktrack(context, [2 | Backtrack.link], head, 2);
     }
     else {
-      assert(rest[0] === ']');
-      if (context.state! & State.annotation) {
-        push(bs, [rest[0]]);
+      assert(source[position] === ']');
+      if (state & State.annotation) {
+        push(bs, [source[position]]);
       }
-      const source = rest.slice(1);
+      context.position += 1;
       let result: ReturnType<typeof textlink>;
-      if (source[0] !== '{') {
-        setBacktrack(context, [2 | Backtrack.link], head - 1);
-        result = [[], source];
+      if (source[context.position] !== '{') {
+        setBacktrack(context, [2 | Backtrack.link], head + 1);
+        result = [[]];
       }
       else {
-        assert(source.length > 0);
-        result = !isBacktrack(context, [1 | Backtrack.link], source)
-          ? textlink({ source, context })
+        result = !isBacktrack(context, [1 | Backtrack.link])
+          ? textlink({ context })
           : undefined;
-        context.recent = recent;
+        context.range = range;
         if (!result) {
-          setBacktrack(context, [2 | Backtrack.link], head - 1);
-          result = [[], source];
+          setBacktrack(context, [2 | Backtrack.link], head + 1);
+          result = [[]];
         }
       }
       assert(result);
-      if (exec(result) === '') {
+      if (context.position === source.length) {
         setBacktrack(context, [2 | Backtrack.link], head);
       }
       else {
-        assert(context.state! ^ State.link);
+        assert(state ^ State.link);
         const next = surround(
           '',
           some(inline, ']', [[']', 1]]),
           str(']'),
           true,
-          ([, cs = [], ds], rest) =>
-            [push(cs, ds), rest],
-          ([, cs = []], rest) => {
+          ([, cs = [], ds]) =>
+            [push(cs, ds)],
+          ([, cs = []]) => {
             setBacktrack(context, [2 | Backtrack.link], head);
-            return [cs, rest];
+            return [cs];
           })
-          ({ source: exec(result), context });
-        if (context.state! & State.annotation && next) {
-          push(push(bs, eval(result)), eval(next));
-          rest = exec(next);
+          ({ context });
+        if (state & State.annotation && next) {
+          return [push(push(unshift(as, bs), eval(result)), eval(next))];
         }
       }
+      context.position = position;
     }
-    return context.state! & State.annotation
-      ? [unshift(as, bs), rest]
+    return state & State.annotation
+      ? [unshift(as, bs)]
       : undefined;
   },
   [3 | Backtrack.doublebracket, 1 | Backtrack.bracket])));
@@ -93,16 +94,24 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
 const abbr: ReferenceParser.AbbrParser = surround(
   str('^'),
   union([str(/^(?=[A-Z])(?:[0-9A-Za-z]'?|(?:[-.:]|\.?\??,? ?)(?!['\-.:?, ]))+/)]),
-  /^\|?(?=]])|^\|[^\S\n]*/,
+  /^\|?(?=]])|^\|/,
   true,
-  ([, ns], rest) => ns ? [[Command.Escape, ns[0].trimEnd()], rest.replace(blank.start, '')] : [[''], `^${rest}`],
-  ([as, bs = ['']], rest) => [[''], as[0] + bs[0] + rest]);
+  ([, ns], context) => {
+    const { source, position, range = 0 } = context;
+    if (!ns) return [['', source.slice(position - range, source[position - 1] === '|' ? position - 1 : position)]];
+    context.position += source.slice(position).match(blank.start)?.[0].length ?? 0;
+    return [[Command.Separator, ns[0].trimEnd()]];
+  },
+  (_, context) => {
+    context.position -= context.range!;
+    return [['']];
+  });
 
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
   switch (ns[0]) {
     case '':
       return { class: 'invalid', ...invalid('reference', 'syntax', 'Invalid abbreviation') };
-    case Command.Escape:
+    case Command.Separator:
       const abbr = ns[1] as string;
       ns[0] = ns[1] = '';
       return { class: 'reference', 'data-abbr': abbr };

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

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

package/src/parser/inline/remark.ts

@@ -16,11 +16,11 @@ export const remark: RemarkParser = lazy(() => match(
       precedence(4, recursion(Recursion.inline,
       some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 4]]))),
       close(some(text, '%'), str(`${fence}]`)), true,
-      ([as, bs = [], cs], rest) => [[
+      ([as, bs = [], cs]) => [[
         html('span', { class: 'remark' }, [
           html('input', { type: 'checkbox' }),
           html('span', defrag(push(unshift(as, bs), cs))),
         ]),
-      ], rest],
-      ([as, bs = []], rest) => [unshift(as, bs), rest]),
+      ]],
+      ([as, bs]) => bs && [unshift(as, bs)]),
   ([, fence]) => fence.length, {})));