securemark 0.281.4 → 0.283.0

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

@@ -6,13 +6,19 @@ 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;
 const ELLIPSIS = '...';
 const PART = (MAX - ELLIPSIS.length) / 2 | 0;
 const REM = MAX - PART * 2 - ELLIPSIS.length;
+const table = [
+  ...[...Array(36)].map((_, i) => i.toString(36)),
+  ...[...Array(36)].map((_, i) => i.toString(36).toUpperCase()).slice(-26),
+  '-', '=',
+].join('');
+assert(table.length === 64);
 export function identity(
   type: 'index' | 'mark' | '',
   id: string | undefined,
@@ -21,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}`
@@ -32,7 +38,7 @@ export function identity(
   const str = text.replace(/\s/g, '_');
   const cs = [...str];
   if (type === '' || cs.length <= MAX) {
-    return `${type}:${id ?? ''}:${str}${/_|[^\S ]|=[0-9a-z]{1,7}$/.test(text) ? `=${hash(text)}` : ''}`;
+    return `${type}:${id ?? ''}:${str}${/_|[^\S ]|=[0-9A-Za-z]{1,6}$/.test(text) ? `=${hash(text)}` : ''}`;
   }
   const s1 = cs.slice(0, PART + REM).join('');
   const s2 = cs.slice(-PART).join('');
@@ -42,6 +48,9 @@ export function identity(
 assert.deepStrictEqual(
   identity('index', undefined, ' 0 '),
   identity('index', undefined, ' 0 '.trim()));
+assert.notDeepStrictEqual(
+  identity('index', undefined, '0 0'),
+  identity('index', undefined, '0  0'));
 assert.notDeepStrictEqual(
   identity('index', undefined, '0 0'),
   identity('index', undefined, '0_0'));
@@ -56,23 +65,44 @@ assert.deepStrictEqual(
   `${'0'.repeat(MAX - 1)}1`);
 assert.deepStrictEqual(
   identity('index', undefined, `0${'1'.repeat(MAX / 2)}${'2'.repeat(MAX / 2)}3`)!.slice(7),
-  `0${'1'.repeat(PART + REM - 1)}${ELLIPSIS}${'2'.repeat(PART - 1)}3=mhy513`);
+  `0${'1'.repeat(PART + REM - 1)}${ELLIPSIS}${'2'.repeat(PART - 1)}3=MYkmc`);
 assert.deepStrictEqual(
   identity('index', undefined, `0${'1'.repeat(MAX * 2)}${'2'.repeat(MAX * 2)}3`)!.slice(7),
-  `0${'1'.repeat(PART + REM - 1)}${ELLIPSIS}${'2'.repeat(PART - 1)}3=12jqtiv`);
+  `0${'1'.repeat(PART + REM - 1)}${ELLIPSIS}${'2'.repeat(PART - 1)}3=3bF8VU`);
 function hash(source: string): string {
   let x = 0;
   for (let i = 0; i < source.length; ++i) {
-    x ^= source.charCodeAt(i) << 1 | 1; // 16+1bit
+    const c = source.charCodeAt(i);
+    x = x ^ c << 1 || ~x ^ c << 1; // 16+1bit
+    assert(x !== 0);
     x ^= x << 13; // shift <= 32-17bit
     x ^= x >>> 17;
     x ^= x << 15;
   }
-  return (x >>> 0).toString(36);
+  return baseR(x >>> 0, 62);
 }
 assert(hash('\x00') !== '0');
 assert(hash('\x01') !== '0');
 assert(hash('\x00') !== hash(String.fromCharCode(1 << 15)));
+// 62も64も最大6桁
+function baseR(n: number, r: number): string {
+  assert(n >= 0);
+  assert(Math.floor(n) === n);
+  assert(r <= 64);
+  let acc = '';
+  do {
+    const mod = n % r;
+    n = (n - mod) / r;
+    assert(Math.floor(n) === n);
+    acc = table[mod] + acc;
+  } while (n > 0)
+  assert(acc !== '');
+  return acc;
+}
+assert(baseR(0, 36) === (0).toString(36));
+assert(baseR(~0 >>> 0, 36) === (~0 >>> 0).toString(36));
+assert(baseR(61, 62) === 'Z');
+assert(baseR(62, 62) === '10');
 
 export function signature(source: Element | DocumentFragment): string {
   assert(!navigator.userAgent.includes('Chrome') || !source.querySelector('br:not(:has(+ :is(ul, ol)))'));

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

@@ -25,8 +25,8 @@ describe('Unit: parser/inline/extension/indexer', () => {
       assert.deepStrictEqual(inspect(parser(' [|a  ]')), [['<span class="indexer" data-index="a"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|a b]')), [['<span class="indexer" data-index="a_b"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|a  b]')), [['<span class="indexer" data-index="a__b"></span>'], '']);
-      assert.deepStrictEqual(inspect(parser(' [|a\tb]')), [['<span class="indexer" data-index="a_b=1eu1tj4"></span>'], '']);
-      assert.deepStrictEqual(inspect(parser(' [|a_b]')), [['<span class="indexer" data-index="a_b=10dxc9b"></span>'], '']);
+      assert.deepStrictEqual(inspect(parser(' [|a\tb]')), [['<span class="indexer" data-index="a_b=33Mw2l"></span>'], '']);
+      assert.deepStrictEqual(inspect(parser(' [|a_b]')), [['<span class="indexer" data-index="a_b=2H8oCG"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|A]')), [['<span class="indexer" data-index="A"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|*A*]')), [['<span class="indexer" data-index="*A*"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|`A`]')), [['<span class="indexer" data-index="`A`"></span>'], '']);

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 } 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))));

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 } from '../context';
 import { trimBlankStart, trimNodeEnd } from '../visibility';
 import { stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
@@ -20,15 +20,15 @@ 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)),
+      true, undefined, undefined, 1)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ])),
   ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
@@ -38,9 +38,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 +57,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.test.ts

@@ -30,7 +30,7 @@ describe('Unit: parser/inline/mark', () => {
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('==a==')), [['<mark id="mark::a">a</mark>', '<a href="#mark::a"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a=b==')), [['<mark id="mark::a=b=1aef5x1">a=b</mark>', '<a href="#mark::a=b=1aef5x1"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a=b==')), [['<mark id="mark::a=b=3lYfIw">a=b</mark>', '<a href="#mark::a=b=3lYfIw"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==\\===')), [['<mark id="mark::=">=</mark>', '<a href="#mark::="></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==a===')), [['<mark id="mark::a">a</mark>', '<a href="#mark::a"></a>'], '=']);
     });
@@ -38,7 +38,7 @@ describe('Unit: parser/inline/mark', () => {
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('==a ==b====')), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==a\\ ==b====')), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark id="mark::a_b=1eu1tj4">a\t<mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b=1eu1tj4"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark id="mark::a_b=33Mw2l">a\t<mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b=33Mw2l"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==a<wbr>==b====')), [['<mark id="mark::ab">a<wbr><mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::ab"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==*==a==*==')), [['<mark id="mark::a"><em><mark id="mark::a">a</mark><a href="#mark::a"></a></em></mark>', '<a href="#mark::a"></a>'], '']);
     });

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 } from '../context';
 import { markInvalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push } from 'spica/array';
@@ -18,10 +18,10 @@ 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(
       '[',
@@ -55,7 +55,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,7 +67,7 @@ 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]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true,

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 } 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]])),
   ]))),
   ']]',
   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)));
 
 // 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

@@ -3,12 +3,12 @@ import { eval, exec } from '../../combinator/data/parser';
 import { sequence, syntax, creation, validate, verify, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } 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(verify(fmap(
   sequence([
     surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']'),
     surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')'),
@@ -51,7 +51,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,18 +1,18 @@
 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 } 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])));
 
-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]),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true,

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) {

package/src/parser/source/str.ts

@@ -1,19 +1,20 @@
 import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
 import { creation } from '../../combinator';
+import { Recursion } from '../context';
 
 export function str(pattern: string | RegExp, not?: string): StrParser;
 export function str(pattern: string | RegExp, not?: string): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creation(1, false, ({ source }) => {
+    ? creation(1, Recursion.ignore, ({ source }) => {
         if (source === '') return;
         if (not && source.slice(pattern.length, pattern.length + not.length) === not) return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creation(1, false, ({ source }) => {
+    : creation(1, Recursion.ignore, ({ source }) => {
         if (source === '') return;
         const m = source.match(pattern);
         if (m && not && source.slice(m[0].length, m[0].length + not.length) === not) return;

package/src/parser/source/text.ts

@@ -1,6 +1,7 @@
 import { TextParser, TxtParser, LinebreakParser } from '../source';
 import { union, creation, focus } from '../../combinator';
 import { str } from './str';
+import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 
 export const delimiter = /[\s\x00-\x7F（）［］｛｝“”‘’「」『』]|\S[#>]/u;
@@ -8,7 +9,7 @@ export const nonWhitespace = /[\S\n]|$/u;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/u;
 const repeat = str(/^(.)\1*/);
 
-export const text: TextParser = creation(1, false, ({ source, context }) => {
+export const text: TextParser = creation(1, Recursion.ignore, ({ source, context }) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/unescapable.ts

@@ -1,8 +1,9 @@
 import { UnescapableSourceParser } from '../source';
 import { creation } from '../../combinator';
 import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
+import { Recursion } from '../context';
 
-export const unescsource: UnescapableSourceParser = creation(1, false, ({ source, context }) => {
+export const unescsource: UnescapableSourceParser = creation(1, Recursion.ignore, ({ source, context }) => {
   assert(source[0] !== '\x1B');
   if (source === '') return;
   const i = source.search(delimiter);