securemark 0.282.0 → 0.283.1

package/src/parser/inline/extension/index.ts

@@ -3,16 +3,16 @@ import { union, inits, some, syntax, creation, precedence, constraint, validate,
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str } from '../../source';
-import { Syntax, State } from '../../context';
+import { State, Recursion, Backtrack } from '../../context';
 import { startTight, trimNodeEnd } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => validate('[#', creation(fmap(indexee(surround(
+export const index: IndexParser = lazy(() => validate('[#', creation(1, Recursion.ignore, fmap(indexee(surround(
   '[#',
   constraint(State.index, false,
-  syntax(Syntax.index, 2, State.linkers | State.media,
+  syntax(2, State.linkers | State.media,
   startTight(
   some(inits([
     inline,
@@ -20,7 +20,8 @@ export const index: IndexParser = lazy(() => validate('[#', creation(fmap(indexe
   ]), ']', [[/^\\?\n/, 9], [']', 2]])))),
   ']',
   false,
-  ([, ns], rest) => [[html('a', trimNodeEnd(defrag(ns)))], rest])),
+  ([, ns], rest) => [[html('a', { 'data-index': dataindex(ns) }, trimNodeEnd(defrag(ns)))], rest],
+  undefined, 1 | Backtrack.bracket)),
   ([el]: [HTMLAnchorElement]) => [
     define(el,
       {
@@ -30,16 +31,27 @@ export const index: IndexParser = lazy(() => validate('[#', creation(fmap(indexe
       }),
   ]))));
 
-export const signature: IndexParser.SignatureParser = lazy(() => validate('|', creation(fmap(open(
+export const signature: IndexParser.SignatureParser = lazy(() => validate('|', creation(1, Recursion.ignore, fmap(open(
   '|',
   startTight(some(union([bracket, txt]), ']'))),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity('index', undefined, ns.join(''))!.slice(7) }),
   ]))));
 
-const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(union([
-  surround(str('('), some(union([bracket, txt]), ')'), str(')'), true),
-  surround(str('['), some(union([bracket, txt]), ']'), str(']'), true),
-  surround(str('{'), some(union([bracket, txt]), '}'), str('}'), true),
-  surround(str('"'), precedence(3, some(txt, '"')), str('"'), true),
+const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
+  surround(str('('), some(union([bracket, txt]), ')'), str(')'), true, undefined, undefined, 3 | Backtrack.index),
+  surround(str('['), some(union([bracket, txt]), ']'), str(']'), true, undefined, undefined, 3 | Backtrack.index),
+  surround(str('{'), some(union([bracket, txt]), '}'), str('}'), true, undefined, undefined, 3 | Backtrack.index),
+  surround(str('"'), precedence(3, some(txt, '"')), str('"'), true, undefined, undefined, 3 | Backtrack.index),
 ])));
+
+export function dataindex(ns: readonly (string | HTMLElement)[]): string | undefined {
+  if (ns.length === 0) return;
+  for (let i = ns.length - 1; i >= 0; --i) {
+    const node = ns[i];
+    if (typeof node === 'string') return;
+    if (i === ns.length - 1 && ['UL', 'OL'].includes(node.tagName)) continue;
+    if (!node.classList.contains('indexer')) return;
+    return node.getAttribute('data-index') ?? undefined;
+  }
+}

package/src/parser/inline/extension/indexee.ts

@@ -6,7 +6,7 @@ import { define } from 'typed-dom/dom';
 
 export function indexee<P extends Parser<unknown, MarkdownParser.Context>>(parser: P): P;
 export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>): Parser<HTMLElement> {
-  return fmap(parser, ([el], _, { id }) => [define(el, { id: identity('index', id, el) })]);
+  return fmap(parser, ([el], _, { id }) => [define(el, { id: identity('index', id, el), 'data-index': null })]);
 }
 
 const MAX = 60;
@@ -27,7 +27,7 @@ export function identity(
   assert(id?.match(/^[0-9a-z/-]*$/i) ?? true);
   if (id === '') return undefined;
   if (typeof text !== 'string') {
-    const index = text.querySelector(':scope > .indexer')?.getAttribute('data-index');
+    const index = text.getAttribute('data-index') ?? undefined;
     if (index === '' && text.tagName === 'LI') return undefined;
     return index
       ? `${type}:${id ?? ''}:${index}`

package/src/parser/inline/extension/indexer.ts

@@ -1,12 +1,13 @@
 import { ExtensionParser } from '../../inline';
 import { union, creation, focus, surround } from '../../../combinator';
 import { signature } from './index';
+import { Recursion } from '../../context';
 import { html } from 'typed-dom/dom';
 
 export const indexer: ExtensionParser.IndexerParser = surround(
   /^\s+\[(?=\|\S)/,
   union([
     signature,
-    creation(focus(/^\|(?=\])/, () => [[html('span', { class: 'indexer', 'data-index': '' })], ''])),
+    creation(1, Recursion.ignore, focus(/^\|(?=\])/, () => [[html('span', { class: 'indexer', 'data-index': '' })], ''])),
   ]),
   /^\]\s*$/);

package/src/parser/inline/extension/label.ts

@@ -1,7 +1,7 @@
 import { ExtensionParser } from '../../inline';
 import { union, constraint, creation, validate, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
-import { State } from '../../context';
+import { State, Recursion } from '../../context';
 import { html } from 'typed-dom/dom';
 
 const body = str(/^\$[A-Za-z]*(?:(?:-[A-Za-z][0-9A-Za-z]*)+|-(?:(?:0|[1-9][0-9]*)\.)*(?:0|[1-9][0-9]*)(?![0-9A-Za-z]))/);
@@ -11,7 +11,7 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(validate
   body,
 ])));
 
-export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creation(fmap(
+export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creation(1, Recursion.ignore, fmap(
   constraint(State.label, false,
   union([
     surround('[', body, ']'),

package/src/parser/inline/extension/placeholder.ts

@@ -2,7 +2,7 @@ import { ExtensionParser } from '../../inline';
 import { union, some, syntax, creation, validate, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { Syntax, State } from '../../context';
+import { State, Recursion, Backtrack } from '../../context';
 import { startTight } from '../../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
@@ -11,9 +11,9 @@ import { html, defrag } from 'typed-dom/dom';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', creation(surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', creation(1, Recursion.inline, surround(
   str(/^\[[:^|]/),
-  syntax(Syntax.placeholder, 2, State.none,
+  syntax(2, State.none,
   startTight(some(union([inline]), ']', [[']', 2]]))),
   str(']'), false,
   ([, bs], rest) => [[
@@ -24,4 +24,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validat
       'data-invalid-message': `Invalid start symbol or linebreak`,
     }, defrag(bs)),
   ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest], 3 | Backtrack.bracket))));

package/src/parser/inline/html.ts

@@ -2,7 +2,7 @@ import { HTMLParser } from '../inline';
 import { union, subsequence, some, syntax, creation, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { isStartLooseNodes, blankWith } from '../visibility';
 import { memoize } from 'spica/memoize';
 import { Clock } from 'spica/clock';
@@ -18,7 +18,7 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(syntax(Syntax.none, 4, State.none, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(1, Recursion.inline, syntax(4, State.none, union([
   focus(
     /^<wbr[^\S\n]*>/i,
     () => [[h('wbr')], '']),

package/src/parser/inline/htmlentity.ts

@@ -1,9 +1,10 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { union, creation, validate, focus, fmap } from '../../combinator';
+import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 
-export const unsafehtmlentity: UnsafeHTMLEntityParser = creation(validate('&', focus(
+export const unsafehtmlentity: UnsafeHTMLEntityParser = creation(1, Recursion.ignore, validate('&', focus(
   /^&[0-9A-Za-z]+;/,
   ({ source }) => [[parse(source) ?? `\x1B${source}`], ''])));
 

package/src/parser/inline/insertion.ts

@@ -2,14 +2,14 @@ import { InsertionParser } from '../inline';
 import { union, some, syntax, creation, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const insertion: InsertionParser = lazy(() => creation(surround(
+export const insertion: InsertionParser = lazy(() => creation(1, Recursion.inline, surround(
   str('++', '+'),
-  syntax(Syntax.none, 1, State.none,
+  syntax(1, State.none,
   some(union([
     some(inline, blankWith('\n', '++')),
     open('\n', some(inline, '+'), true),

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

@@ -13,10 +13,10 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K}')), [['<a class="invalid">data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{any:alert}')), [['<a class="invalid">any:alert</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{"}')), [['<a class="url" href="&quot;">"</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{<}')), [['<a class="url" href="<">&lt;</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{<}')), [['<a class="url" href="&lt;">&lt;</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\}')), [['<a class="url" href="\\">\\</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\"}')), [['<a class="url" href="\\&quot;">\\"</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{\\<}')), [['<a class="url" href="\\<">\\&lt;</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{\\<}')), [['<a class="url" href="\\&lt;">\\&lt;</a>'], '']);
     });
 
     it('fishing', () => {

package/src/parser/inline/link.ts

@@ -4,7 +4,7 @@ import { union, inits, tails, sequence, some, constraint, syntax, creation, prec
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { linebreak, unescsource, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion, Backtrack } from '../context';
 import { trimBlankStart, trimNodeEnd } from '../visibility';
 import { stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
@@ -20,16 +20,20 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], union([
   textlink,
 ])));
 
-export const textlink: LinkParser.TextLinkParser = lazy(() => creation(10,
+export const textlink: LinkParser.TextLinkParser = lazy(() => creation(1, Recursion.ignore,
   constraint(State.link, false,
-  syntax(Syntax.link, 2, State.linkers | State.media,
+  syntax(2, State.linkers | State.media,
   bind(reverse(tails([
     dup(surround(
       '[',
       trimBlankStart(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]])),
       ']',
-      true)),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+      true, undefined, undefined, 1 | Backtrack.bracket)),
+    dup(surround(
+      /^{(?![{}])/,
+      inits([uri, some(option)]),
+      /^[^\S\n]*}/,
+      false, undefined, undefined, 3 | Backtrack.link)),
   ])),
   ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
     assert(!html('div', content).querySelector('a, .media, .annotation, .reference'));
@@ -38,9 +42,9 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => creation(10,
     return [[parse(content, params, context)], rest];
   })))));
 
-export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(10,
+export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(1, Recursion.ignore,
   constraint(State.link | State.media, false,
-  syntax(Syntax.link, 2, State.linkers,
+  syntax(2, State.linkers,
   bind(reverse(sequence([
     dup(surround(
       '[',
@@ -57,7 +61,7 @@ export const linemedialink: LinkParser.LineMediaLinkParser = surround(
   /^(?=[^\S\n]*(?:$|\n))/);
 
 export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
-  creation(10, precedence(2,
+  creation(1, Recursion.ignore, precedence(2,
   bind(reverse(tails([
     dup(surround(
       '[',

package/src/parser/inline/mark.ts

@@ -4,14 +4,14 @@ import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { unshift } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => creation(surround(
+export const mark: MarkParser = lazy(() => creation(1, Recursion.inline, surround(
   str('==', '='),
   constraint(State.mark, false,
-  syntax(Syntax.none, 1, State.none,
+  syntax(1, State.none,
   startTight(some(union([
     some(inline, blankWith('=='), [[/^\\?\n/, 9]]),
     open(some(inline, '=', [[/^\\?\n/, 9]]), mark),

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

@@ -115,8 +115,8 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$(0, 1]$)')), [['<span class="math" translate="no" data-src="$(0, 1]$">$(0, 1]$</span>'], ')']);
       assert.deepStrictEqual(inspect(parser('$\\{0,1\\}$')), [['<span class="math" translate="no" data-src="$\\{0,1\\}$">$\\{0,1\\}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$n=1$')), [['<span class="math" translate="no" data-src="$n=1$">$n=1$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$n<m$')), [['<span class="math" translate="no" data-src="$n<m$">$n&lt;m$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$n>m$')), [['<span class="math" translate="no" data-src="$n>m$">$n&gt;m$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$n<m$')), [['<span class="math" translate="no" data-src="$n&lt;m$">$n&lt;m$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$n>m$')), [['<span class="math" translate="no" data-src="$n&gt;m$">$n&gt;m$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$E = mc^2$')), [['<span class="math" translate="no" data-src="$E = mc^2$">$E = mc^2$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$f(x)$')), [['<span class="math" translate="no" data-src="$f(x)$">$f(x)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$f: x \\to y$')), [['<span class="math" translate="no" data-src="$f: x \\to y$">$f: x \\to y$</span>'], '']);
@@ -143,7 +143,7 @@ describe('Unit: parser/inline/math', () => {
 
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('${*a*}$')), [['<span class="math" translate="no" data-src="${*a*}$">${*a*}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('${<wbr>}$')), [['<span class="math" translate="no" data-src="${<wbr>}$">${&lt;wbr&gt;}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${<wbr>}$')), [['<span class="math" translate="no" data-src="${&lt;wbr&gt;}$">${&lt;wbr&gt;}$</span>'], '']);
     });
 
   });

package/src/parser/inline/math.ts

@@ -1,11 +1,12 @@
 import { MathParser } from '../inline';
 import { union, some, creation, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
-import { escsource, unescsource } from '../source';
+import { escsource, unescsource, str } from '../source';
+import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
-export const math: MathParser = lazy(() => validate('$', creation(rewrite(
+export const math: MathParser = lazy(() => validate('$', creation(1, Recursion.ignore, rewrite(
   union([
     surround('$', precedence(6, bracket), '$'),
     surround(
@@ -31,11 +32,11 @@ export const math: MathParser = lazy(() => validate('$', creation(rewrite(
       source)
   ], '']))));
 
-const bracket: MathParser.BracketParser = lazy(() => creation(surround(
-  '{',
+const bracket: MathParser.BracketParser = lazy(() => creation(0, Recursion.terminal, surround(
+  str('{'),
   some(union([
     bracket,
     some(escsource, /^(?:[{}$]|\\?\n)/),
   ])),
-  '}',
+  str('}'),
   true)));

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

@@ -91,7 +91,7 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![\\[]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="["></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![\\"]{"?"#"}')), [['<a href="&quot;?&quot;#&quot;" target="_blank"><img class="media" data-src="&quot;?&quot;#&quot;" alt="&quot;"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![*a*]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="*a*"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![<wbr>]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="<wbr>"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![<wbr>]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="&lt;wbr&gt;"></a>'], '']);
     });
 
     it('external', () => {

package/src/parser/inline/media.ts

@@ -4,7 +4,7 @@ import { unsafelink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, linebreak, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion, Backtrack } from '../context';
 import { markInvalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push } from 'spica/array';
@@ -18,17 +18,21 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(10, open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(1, Recursion.ignore, open(
   '!',
   constraint(State.media, false,
-  syntax(Syntax.none, 2, ~State.link,
+  syntax(2, ~State.link,
   bind(verify(fmap(tails([
     dup(surround(
       '[',
       some(union([unsafehtmlentity, bracket, txt]), ']', [[/^\\?\n/, 9]]),
       ']',
-      true)),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+      true, undefined, undefined, 1 | Backtrack.media)),
+    dup(surround(
+      /^{(?![{}])/,
+      inits([uri, some(option)]),
+      /^[^\S\n]*}/,
+      false, undefined, undefined, 3 | Backtrack.link)),
   ]),
   ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], bs] : [[''], as]),
   ([[text]]) => text === '' || text.trim() !== ''),
@@ -55,7 +59,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(10,
       el.style.aspectRatio = el.getAttribute('aspect-ratio')!;
     }
     if (context.state! & State.link) return [[el], rest];
-    if (cache && cache.tagName !== 'IMG') return creation(10, _ => [[el!], rest])({ source: '!', context });
+    if (cache && cache.tagName !== 'IMG') return [[el], rest];
     return fmap(
       unsafelink as MediaParser,
       ([link]) => [define(link, { class: null, target: '_blank' }, [el])])
@@ -67,14 +71,15 @@ export const linemedia: MediaParser.LineMediaParser = surround(
   union([media]),
   /^(?=[^\S\n]*(?:$|\n))/);
 
-const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(union([
+const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('"'), precedence(3, some(union([unsafehtmlentity, txt]), '"')), str('"'), true),
+    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
+  surround(str('"'), precedence(3, some(union([unsafehtmlentity, txt]), '"')), str('"'), true,
+    undefined, undefined, 3 | Backtrack.media),
 ])));
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([

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

@@ -13,6 +13,9 @@ describe('Unit: parser/inline/reference', () => {
       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);

package/src/parser/inline/reference.ts

@@ -2,24 +2,25 @@ import { ReferenceParser } from '../inline';
 import { union, subsequence, some, syntax, creation, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion, Backtrack } from '../context';
 import { blank, trimBlankStart, trimNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => creation(surround(
+export const reference: ReferenceParser = lazy(() => creation(1, Recursion.ignore, surround(
   '[[',
   constraint(State.reference, false,
-  syntax(Syntax.reference, 6, State.annotation | State.reference | State.media,
+  syntax(6, State.annotation | State.reference | State.media,
   subsequence([
     abbr,
-    trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
+    trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 2]])),
   ]))),
   ']]',
   false,
-  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest])));
+  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  undefined, 1 | Backtrack.bracket)));
 
 // Chicago-Style
-const abbr: ReferenceParser.AbbrParser = creation(surround(
+const abbr: ReferenceParser.AbbrParser = creation(1, Recursion.ignore, surround(
   '^',
   union([str(/^(?=[A-Z])(?:[0-9A-Za-z]'?|(?:[-.:]|\.?\??,? ?)(?!['\-.:?, ]))+/)]),
   /^\|?(?=]])|^\|[^\S\n]*/,

package/src/parser/inline/remark.ts

@@ -2,12 +2,12 @@ import { RemarkParser } from '../inline';
 import { union, some, syntax, creation, validate, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const remark: RemarkParser = lazy(() => validate('[%', creation(syntax(Syntax.none, 5, State.none, match(
+export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recursion.inline, syntax(5, State.none, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>

package/src/parser/inline/ruby.ts

@@ -1,25 +1,26 @@
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, syntax, creation, validate, verify, surround, lazy, fmap } from '../../combinator';
+import { sequence, syntax, creation, validate, surround, lazy, fmap, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion, Backtrack } from '../context';
 import { isStartTightNodes } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const ruby: RubyParser = lazy(() => validate('[', creation(syntax(Syntax.ruby, 2, State.all, fmap(verify(fmap(
+export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.ignore, syntax(2, State.all, fmap(
   sequence([
-    surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']'),
-    surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')'),
+    bind(surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {
+      const ns = eval(text({ source, context }), [undefined])[0];
+      ns && ns[ns.length - 1] === '' && ns.pop();
+      return ns && isStartTightNodes(ns) ? [[ns], rest] : undefined;
+    }),
+    bind(surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {
+      const ns = eval(text({ source, context }), [undefined])[0];
+      return ns && [[ns], rest];
+    }),
   ]),
-  ([texts, rubies], _, context) => [
-    eval(text({ source: texts, context }), [])[0] ?? '',
-    eval(text({ source: rubies, context }), [])[0] ?? '',
-  ]),
-  ([texts, rubies]) => texts && rubies && isStartTightNodes(texts)),
   ([texts, rubies]) => {
-    texts[texts.length - 1] === '' && texts.pop();
     switch (true) {
       case rubies.length <= texts.length:
         return [
@@ -51,7 +52,7 @@ export const ruby: RubyParser = lazy(() => validate('[', creation(syntax(Syntax.
     }
   })))));
 
-const text: RubyParser.TextParser = creation(1, false, ({ source, context }) => {
+const text: RubyParser.TextParser = creation(1, Recursion.ignore, ({ source, context }) => {
   const acc = [''];
   while (source !== '') {
     assert(source[0] !== '\n');

package/src/parser/inline/strong.ts

@@ -3,14 +3,14 @@ import { union, some, syntax, creation, surround, open, lazy } from '../../combi
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const strong: StrongParser = lazy(() => creation(surround(
+export const strong: StrongParser = lazy(() => creation(1, Recursion.inline, surround(
   str('**', '*'),
-  syntax(Syntax.none, 1, State.none,
+  syntax(1, State.none,
   startTight(some(union([
     some(inline, blankWith('**'), [[/^\\?\n/, 9]]),
     open(some(inline, '*', [[/^\\?\n/, 9]]), union([

package/src/parser/inline/template.ts

@@ -1,23 +1,25 @@
 import { TemplateParser } from '../inline';
 import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion, Backtrack } from '../context';
 import { unshift } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
-export const template: TemplateParser = lazy(() => creation(surround(
+export const template: TemplateParser = lazy(() => creation(1, Recursion.ignore, surround(
   '{{',
-  syntax(Syntax.none, 6, State.all, some(union([bracket, escsource]), '}', [['}}', 6]])),
+  syntax(6, State.all, some(union([bracket, escsource]), '}', [['}}', 6]])),
   '}}',
   true,
-  ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest])));
+  ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest],
+  undefined, 3 | Backtrack.template)));
 
-const bracket: TemplateParser.BracketParser = lazy(() => creation(union([
+const bracket: TemplateParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
   surround(str('('), some(union([bracket, escsource]), ')'), str(')'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('"'), precedence(3, some(escsource, /^"|^\\?\n/)), str('"'), true),
+    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
+  surround(str('"'), precedence(3, some(escsource, /^"|^\\?\n/)), str('"'), true,
+    undefined, undefined, 3 | Backtrack.template),
 ])));

package/src/parser/inline.test.ts

@@ -148,8 +148,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('(((a))')), [['(', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))')), [['(', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((${))}$')), [['(', '(', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('((a\nb))')), [['<span class="paren">(<span class="paren">(a<br>b)</span>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</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>'], '']);
@@ -158,7 +158,6 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><span><a class="url" href="a">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a class="link" href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a class="link" href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['[', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[==a==]{b}')), [['<a class="link" href="b">==a==</a>'], '']);

package/src/parser/inline.ts

@@ -70,6 +70,7 @@ export const inline: InlineParser = lazy(() => union([
 
 export { indexee } from './inline/extension/indexee';
 export { indexer } from './inline/extension/indexer';
+export { dataindex } from './inline/extension/index';
 export { medialink } from './inline/link';
 export { media } from './inline/media';
 export { shortmedia } from './inline/shortmedia';

package/src/parser/source/escapable.ts

@@ -1,10 +1,11 @@
 import { EscapableSourceParser } from '../source';
 import { creation } from '../../combinator';
 import { nonWhitespace } from './text';
+import { Recursion } from '../context';
 
 const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
-export const escsource: EscapableSourceParser = creation(1, false, ({ source, context }) => {
+export const escsource: EscapableSourceParser = creation(1, Recursion.ignore, ({ source, context }) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {