securemark 0.281.4 → 0.283.0

package/src/parser/block/ilist.ts

@@ -3,6 +3,7 @@ import { union, inits, some, creation, block, line, validate, indent, open, trim
 import { ulist_, invalid, fillFirstLine } from './ulist';
 import { olist_ } from './olist';
 import { inline } from '../inline';
+import { Recursion } from '../context';
 import { lineable } from '../util';
 import { visualize, trimBlank } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
@@ -13,7 +14,7 @@ export const ilist: IListParser = lazy(() => block(validate(
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(
   /^[-+*](?:$|\s)/,
-  some(creation(1, false, union([
+  some(creation(0, Recursion.listitem, union([
     fmap(fallback(
       inits([
         line(open(/^[-+*](?:$|\s)/, trim(visualize(trimBlank(lineable(some(inline))))), true)),

package/src/parser/block/olist.ts

@@ -2,9 +2,10 @@ import { OListParser } from '../block';
 import { union, inits, subsequence, some, creation, block, line, validate, indent, focus, open, match, trim, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, checkbox, invalid, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
-import { inline, indexee, indexer } from '../inline';
+import { inline, indexee, indexer, dataindex } from '../inline';
 import { lineable } from '../util';
 import { visualize, trimBlank } from '../visibility';
+import { Recursion } from '../context';
 import { memoize } from 'spica/memoize';
 import { html, define, defrag } from 'typed-dom/dom';
 
@@ -30,7 +31,7 @@ export const olist_: OListParser = lazy(() => block(union([
 ])));
 
 const list = (type: string, form: string): OListParser.ListParser => fmap(
-  some(creation(1, false, union([
+  some(creation(0, Recursion.listitem, union([
     indexee(fmap(fallback(
       inits([
         line(open(heads[form], subsequence([
@@ -39,7 +40,7 @@ const list = (type: string, form: string): OListParser.ListParser => fmap(
         indent(union([ulist_, olist_, ilist_])),
       ]),
       invalid),
-      ns => [html('li', { 'data-marker': ns.shift() as string || undefined }, defrag(fillFirstLine(ns)))])),
+      ns => [html('li', { 'data-index': dataindex(ns), 'data-marker': ns.shift() as string || undefined }, defrag(fillFirstLine(ns)))])),
   ]))),
   es => [format(html('ol', es), type, form)]);
 

package/src/parser/block/reply/cite.ts

@@ -1,10 +1,10 @@
 import { ReplyParser } from '../../block';
-import { union, tails, creation, line, validate, focus, reverse, fmap } from '../../../combinator';
+import { union, tails, line, validate, focus, reverse, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const cite: ReplyParser.CiteParser = creation(1, false, line(fmap(validate(
+export const cite: ReplyParser.CiteParser = line(fmap(validate(
   '>>',
   reverse(tails([
     str(/^>*(?=>>[^>\s]+\s*$)/),
@@ -23,4 +23,4 @@ export const cite: ReplyParser.CiteParser = creation(1, false, line(fmap(validat
       define(el, { 'data-depth': `${quotes.length + 1}` }, el.innerText.slice(1)),
     ])),
     html('br'),
-  ])));
+  ]));

package/src/parser/block/reply/quote.ts

@@ -1,5 +1,5 @@
 import { ReplyParser } from '../../block';
-import { union, some, creation, block, line, validate, rewrite, convert, lazy, fmap } from '../../../combinator';
+import { union, some, block, line, validate, rewrite, convert, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { autolink } from '../../inline/autolink';
 import { linebreak, unescsource, str, anyline } from '../../source';
@@ -7,7 +7,7 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const syntax = /^>+(?=[^\S\n])|^>(?=[^\s>])|^>+(?=[^\s>])(?![0-9a-z]+(?:-[0-9a-z]+)*(?![0-9A-Za-z@#:]))/;
 
-export const quote: ReplyParser.QuoteParser = lazy(() => creation(1, false, block(fmap(validate(
+export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(validate(
   '>',
   union([
     rewrite(
@@ -30,7 +30,7 @@ export const quote: ReplyParser.QuoteParser = lazy(() => creation(1, false, bloc
       defrag(ns)),
     html('br'),
   ]),
-  false)));
+  false));
 
 const qblock: ReplyParser.QuoteParser.BlockParser = convert(
   source => source.replace(/\n$/, '').replace(/(?<=^>+[^\S\n])/mg, '\r'),

package/src/parser/block/sidefence.ts

@@ -2,6 +2,7 @@ import { SidefenceParser } from '../block';
 import { union, some, creation, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
+import { Recursion } from '../context';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
@@ -20,7 +21,7 @@ const opener = /^(?=\|\|+(?:$|\s))/;
 const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?:[^\S\n]|(?=\|*(?:$|\s)))|\n$/g, '');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
-  some(creation(1, false, union([
+  some(creation(0, Recursion.block, union([
     focus(
       /^(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/,
       convert(unindent, source, true)),

package/src/parser/block/table.ts

@@ -1,5 +1,5 @@
 import { TableParser } from '../block';
-import { union, sequence, some, creation, block, line, validate, focus, rewrite, surround, open, close, trimStart, fallback, lazy, fmap } from '../../combinator';
+import { union, sequence, some, block, line, validate, focus, rewrite, surround, open, close, trimStart, fallback, lazy, fmap } from '../../combinator';
 import { inline, media, medialink, shortmedia } from '../inline';
 import { contentline } from '../source';
 import { trimBlankStart, trimNodeEnd } from '../visibility';
@@ -25,7 +25,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
     ]),
   ])));
 
-const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creation(1, false, fallback(fmap(
+const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => fallback(fmap(
   line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
   es => [html('tr', es)]),
   rewrite(contentline, ({ source }) => [[
@@ -35,9 +35,9 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
       'data-invalid-type': 'syntax',
       'data-invalid-message': 'Missing the start symbol of the table row',
     }, [html('td', source.replace('\n', ''))])
-  ], ''])));
+  ], '']));
 
-const align: AlignParser = creation(1, false, fmap(open(
+const align: AlignParser = fmap(open(
   '|',
   union([
     focus(/^:-+:/, () => [['center'], '']),
@@ -45,7 +45,7 @@ const align: AlignParser = creation(1, false, fmap(open(
     focus(/^-+:/, () => [['end'], '']),
     focus(/^-+/, () => [[''], '']),
   ])),
-  ns => [html('td', defrag(ns))]));
+  ns => [html('td', defrag(ns))]);
 
 const cell: CellParser = surround(
   /^\|\s*(?=\S)/,
@@ -57,13 +57,13 @@ const cell: CellParser = surround(
   ])),
   /^[^|]*/, true);
 
-const head: CellParser.HeadParser = creation(1, false, fmap(
+const head: CellParser.HeadParser = fmap(
   cell,
-  ns => [html('th', trimNodeEnd(defrag(ns)))]));
+  ns => [html('th', trimNodeEnd(defrag(ns)))]);
 
-const data: CellParser.DataParser = creation(1, false, fmap(
+const data: CellParser.DataParser = fmap(
   cell,
-  ns => [html('td', trimNodeEnd(defrag(ns)))]));
+  ns => [html('td', trimNodeEnd(defrag(ns)))]);
 
 function format(rows: HTMLTableRowElement[]): HTMLTableRowElement[] {
   const aligns = rows[0].className === 'invalid'

package/src/parser/block/ulist.ts

@@ -3,8 +3,9 @@ import { Parser } from '../../combinator/data/parser';
 import { union, inits, subsequence, some, creation, block, line, validate, indent, focus, rewrite, open, trim, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_ } from './ilist';
-import { inline, indexer, indexee } from '../inline';
+import { inline, indexer, indexee, dataindex } from '../inline';
 import { contentline } from '../source';
+import { Recursion } from '../context';
 import { lineable } from '../util';
 import { visualize, trimBlank } from '../visibility';
 import { unshift } from 'spica/array';
@@ -16,7 +17,7 @@ export const ulist: UListParser = lazy(() => block(validate(
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
   /^-(?=$|\s)/,
-  some(creation(1, false, union([
+  some(creation(0, Recursion.listitem, union([
     indexee(fmap(fallback(
       inits([
         line(open(/^-(?:$|\s)/, subsequence([
@@ -26,15 +27,15 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
         indent(union([ulist_, olist_, ilist_])),
       ]),
       invalid),
-      ns => [html('li', defrag(fillFirstLine(ns)))])),
+      ns => [html('li', { 'data-index': dataindex(ns) }, defrag(fillFirstLine(ns)))])),
   ])))),
   es => [format(html('ul', es))])));
 
-export const checkbox = creation(1, false, focus(
+export const checkbox = focus(
   /^\[[xX ]\](?=$|\s)/,
   ({ source }) => [[
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
-  ], '']));
+  ], '']);
 
 export const invalid = rewrite(
   inits([contentline, indent<Parser<string>>(({ source }) => [[source], ''])]),

package/src/parser/block.ts

@@ -1,5 +1,5 @@
 import { MarkdownParser } from '../../markdown';
-import { union, reset, creation, open, fallback, recover } from '../combinator';
+import { union, reset, open, fallback, recover } from '../combinator';
 import { emptyline } from './source';
 import { pagebreak } from './block/pagebreak';
 import { heading } from './block/heading';
@@ -16,6 +16,7 @@ import { blockquote } from './block/blockquote';
 import { mediablock } from './block/mediablock';
 import { reply } from './block/reply';
 import { paragraph } from './block/paragraph';
+import { Recursion } from './context';
 import { rnd0Z } from 'spica/random';
 import { html } from 'typed-dom/dom';
 
@@ -36,9 +37,19 @@ export import MediaBlockParser = BlockParser.MediaBlockParser;
 export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
-export const block: BlockParser = creation(0, false,
-  reset({
-    resources: { clock: 20000, recursion: 20 + 1 },
+export const block: BlockParser = reset(
+  {
+    resources: {
+      clock: 20000,
+      recursions: [
+        10 || Recursion.block,
+        20 || Recursion.blockquote,
+        40 || Recursion.listitem,
+        20 || Recursion.inline,
+        20 || Recursion.bracket,
+        20 || Recursion.terminal,
+      ],
+    },
   },
   error(union([
     emptyline,
@@ -57,7 +68,7 @@ export const block: BlockParser = creation(0, false,
     mediablock,
     reply,
     paragraph
-  ]))));
+  ])));
 
 function error(parser: BlockParser): BlockParser {
   return recover<BlockParser>(fallback(

package/src/parser/context.ts

@@ -1,23 +1,3 @@
-export const enum Syntax {
-  annotation = 1 << 8,
-  reference = 1 << 7,
-  index = 1 << 6,
-  placeholder = 1 << 5,
-  ruby = 1 << 4,
-  link = 1 << 3,
-  bracket = 1 << 2,
-  autolink = 1 << 1,
-  none = 0,
-  targets = 0
-    | Syntax.annotation
-    | Syntax.reference
-    | Syntax.index
-    | Syntax.placeholder
-    | Syntax.ruby
-    | Syntax.link
-    | Syntax.bracket,
-}
-
 export const enum State {
   annotation = 1 << 8,
   reference = 1 << 7,
@@ -40,4 +20,12 @@ export const enum State {
     | State.autolink,
 }
 
-export const Margin = 2;
+export const enum Recursion {
+  ignore,
+  block,
+  blockquote,
+  listitem,
+  inline,
+  bracket,
+  terminal,
+}

package/src/parser/inline/annotation.ts

@@ -1,15 +1,16 @@
 import { AnnotationParser } from '../inline';
 import { union, some, syntax, creation, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { trimBlankStart, trimNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const annotation: AnnotationParser = lazy(() => creation(surround(
+export const annotation: AnnotationParser = lazy(() => creation(1, Recursion.ignore, surround(
   '((',
   constraint(State.annotation, false,
-  syntax(Syntax.annotation, 6, State.annotation | State.media,
+  syntax(6, State.annotation | State.media,
   trimBlankStart(some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2], ['))', 6]])))),
   '))',
   false,
-  ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])], rest])));
+  ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  undefined, 1)));

package/src/parser/inline/autolink/email.ts

@@ -1,11 +1,12 @@
 import { AutolinkParser } from '../../inline';
 import { creation, verify, rewrite } from '../../../combinator';
 import { str } from '../../source';
+import { Recursion } from '../../context';
 import { html } from 'typed-dom/dom';
 
 // https://html.spec.whatwg.org/multipage/input.html
 
-export const email: AutolinkParser.EmailParser = creation(rewrite(verify(
+export const email: AutolinkParser.EmailParser = creation(1, Recursion.ignore, rewrite(verify(
   str(/^[0-9a-z](?:[_.+-](?=[0-9a-z])|[0-9a-z]){0,255}@[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?(?:\.[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?)*(?![0-9a-z])/i),
   ([source]) => source.length <= 255),
   ({ source }) => [[html('a', { class: 'email', href: `mailto:${source}` }, source)], '']));

package/src/parser/inline/autolink/url.ts

@@ -2,6 +2,7 @@ import { AutolinkParser } from '../../inline';
 import { union, tails, some, creation, precedence, validate, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { linebreak, unescsource, str } from '../../source';
+import { Recursion } from '../../context';
 
 const closer = /^[-+*=~^_,.;:!?]*(?=[\\"`|\[\](){}<>]|$)/;
 
@@ -24,9 +25,9 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => open(
         unsafelink)),
   ])));
 
-const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creation(precedence(2, union([
-  surround('(', some(union([bracket, unescsource]), ')'), ')', true),
-  surround('[', some(union([bracket, unescsource]), ']'), ']', true),
-  surround('{', some(union([bracket, unescsource]), '}'), '}', true),
-  surround('"', precedence(3, some(unescsource, '"')), '"', true),
+const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creation(0, Recursion.terminal, precedence(2, union([
+  surround(str('('), some(union([bracket, unescsource]), ')'), str(')'), true),
+  surround(str('['), some(union([bracket, unescsource]), ']'), str(']'), true),
+  surround(str('{'), some(union([bracket, unescsource]), '}'), str('}'), true),
+  surround(str('"'), precedence(3, some(unescsource, '"')), str('"'), true),
 ]))));

package/src/parser/inline/autolink.ts

@@ -8,13 +8,13 @@ import { hashtag, emoji } from './autolink/hashtag';
 import { hashnum } from './autolink/hashnum';
 import { anchor } from './autolink/anchor';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State } from '../context';
 import { stringify } from '../util';
 
 export const autolink: AutolinkParser = lazy(() =>
   validate(/^(?:[@#>0-9a-z]|\S[#>]|[\r\n]!?https?:\/\/)/iu,
   constraint(State.autolink, false,
-  syntax(Syntax.autolink, 1, ~State.shortcut,
+  syntax(1, ~State.shortcut,
   union([
     some(union([lineurl])),
     fmap(some(union([

package/src/parser/inline/bracket.ts

@@ -2,46 +2,46 @@ import { BracketParser } from '../inline';
 import { union, some, syntax, creation, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
 export const bracket: BracketParser = lazy(() => union([
-  surround(str('('), creation(syntax(Syntax.none, 2, State.none, str(index))), str(')')),
-  surround(str('('), creation(syntax(Syntax.bracket, 2, State.none, some(inline, ')', [[/^\\?\n/, 3], [')', 2]]))), str(')'), true,
+  surround(str('('), creation(0, Recursion.bracket, syntax(2, State.none, str(index))), str(')')),
+  surround(str('('), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, ')', [[/^\\?\n/, 3], [')', 2]]))), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('（'), creation(syntax(Syntax.none, 2, State.none, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))))), str('）')),
-  surround(str('（'), creation(syntax(Syntax.bracket, 2, State.none, some(inline, '）', [[/^\\?\n/, 3], ['）', 2]]))), str('）'), true,
+    ([as, bs = []], rest) => [unshift(as, bs), rest], 3),
+  surround(str('（'), creation(0, Recursion.bracket, syntax(2, State.none, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))))), str('）')),
+  surround(str('（'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '）', [[/^\\?\n/, 3], ['）', 2]]))), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('['), creation(syntax(Syntax.bracket, 2, State.none, some(inline, ']', [[/^\\?\n/, 3], [']', 2]]))), str(']'), true,
+  surround(str('['), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, ']', [[/^\\?\n/, 3], [']', 2]]))), str(']'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('［'), creation(syntax(Syntax.bracket, 2, State.none, some(inline, '］', [[/^\\?\n/, 3], ['］', 2]]))), str('］'), true,
+    ([as, bs = []], rest) => [unshift(as, bs), rest], 3),
+  surround(str('［'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '］', [[/^\\?\n/, 3], ['］', 2]]))), str('］'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('{'), creation(syntax(Syntax.bracket, 2, State.none, some(inline, '}', [[/^\\?\n/, 3], ['}', 2]]))), str('}'), true,
+  surround(str('{'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '}', [[/^\\?\n/, 3], ['}', 2]]))), str('}'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('｛'), creation(syntax(Syntax.bracket, 2, State.none, some(inline, '｝', [[/^\\?\n/, 3], ['｝', 2]]))), str('｝'), true,
+    ([as, bs = []], rest) => [unshift(as, bs), rest], 3),
+  surround(str('｛'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '｝', [[/^\\?\n/, 3], ['｝', 2]]))), str('｝'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('"'), creation(syntax(Syntax.none, 3, State.none, some(inline, '"', [[/^\\?\n/, 4], ['"', 3]]))), str('"'), true,
+  surround(str('"'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '"', [[/^\\?\n/, 4], ['"', 3]]))), str('"'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('“'), creation(syntax(Syntax.none, 3, State.none, some(inline, '”', [[/^\\?\n/, 4], ['”', 3]]))), str('”'), true,
+  surround(str('“'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '”', [[/^\\?\n/, 4], ['”', 3]]))), str('”'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('‘'), creation(syntax(Syntax.none, 3, State.none, some(inline, '’', [[/^\\?\n/, 4], ['’', 3]]))), str('’'), true,
+  surround(str('‘'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '’', [[/^\\?\n/, 4], ['’', 3]]))), str('’'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('「'), creation(syntax(Syntax.none, 3, State.none, some(inline, '」', [[/^\\?\n/, 4], ['」', 3]]))), str('」'), true,
+  surround(str('「'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '」', [[/^\\?\n/, 4], ['」', 3]]))), str('」'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('『'), creation(syntax(Syntax.none, 3, State.none, some(inline, '』', [[/^\\?\n/, 4], ['』', 3]]))), str('』'), true,
+  surround(str('『'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '』', [[/^\\?\n/, 4], ['』', 3]]))), str('』'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
 ]));

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

@@ -37,7 +37,7 @@ describe('Unit: parser/inline/code', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('`<wbr>`')), [['<code data-src="`<wbr>`">&lt;wbr&gt;</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`<wbr>`')), [['<code data-src="`&lt;wbr&gt;`">&lt;wbr&gt;</code>'], '']);
       assert.deepStrictEqual(inspect(parser('`*u*`')), [['<code data-src="`*u*`">*u*</code>'], '']);
     });
 

package/src/parser/inline/code.ts

@@ -1,8 +1,9 @@
 import { CodeParser } from '../inline';
 import { creation, validate, match } from '../../combinator';
+import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 
-export const code: CodeParser = creation(validate('`', match(
+export const code: CodeParser = creation(1, Recursion.ignore, validate('`', match(
   /^(`+)(?!`)([^\n]*?[^`\n])\1(?!`)/,
   ([whole, , body]) => ({ source }) =>
     [[html('code', { 'data-src': whole }, format(body))], source.slice(whole.length)])));

package/src/parser/inline/deletion.ts

@@ -2,14 +2,14 @@ import { DeletionParser } 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 deletion: DeletionParser = lazy(() => creation(surround(
+export const deletion: DeletionParser = 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/emphasis.ts

@@ -4,14 +4,14 @@ import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { strong } from './strong';
 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 emphasis: EmphasisParser = lazy(() => creation(surround(
+export const emphasis: EmphasisParser = lazy(() => creation(1, Recursion.inline, surround(
   str('*', '*'),
-  syntax(Syntax.none, 1, State.none,
+  syntax(1, State.none,
   startTight(some(union([
     strong,
     some(inline, blankWith('*'), [[/^\\?\n/, 9]]),

package/src/parser/inline/emstrong.ts

@@ -5,7 +5,7 @@ import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
@@ -27,9 +27,9 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => creation(surround(
+export const emstrong: EmStrongParser = 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]]), inline),

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

@@ -51,8 +51,8 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#a\\ ]')), [['<a class="index" href="#index::a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a b]')), [['<a class="index" href="#index::a_b">a b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a  b]')), [['<a class="index" href="#index::a__b">a  b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a\tb]')), [['<a class="index" href="#index::a_b=1eu1tj4">a\tb</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a_b]')), [['<a class="index" href="#index::a_b=10dxc9b">a_b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a\tb]')), [['<a class="index" href="#index::a_b=33Mw2l">a\tb</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a_b]')), [['<a class="index" href="#index::a_b=2H8oCG">a_b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a\\ b]')), [['<a class="index" href="#index::a_b">a b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#[]]')), [['<a class="index" href="#index::[]">[]</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#\\]]')), [['<a class="index" href="#index::]">]</a>'], '']);
@@ -87,8 +87,8 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#a|*b*]')), [['<a class="index" href="#index::*b*">a<span class="indexer" data-index="*b*"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|b c]')), [['<a class="index" href="#index::b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|b  c]')), [['<a class="index" href="#index::b__c">a<span class="indexer" data-index="b__c"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|b\tc]')), [['<a class="index" href="#index::b_c=3p5wqt">a<span class="indexer" data-index="b_c=3p5wqt"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|b_c]')), [['<a class="index" href="#index::b_c=fvw9e2">a<span class="indexer" data-index="b_c=fvw9e2"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b\tc]')), [['<a class="index" href="#index::b_c=xeqYk">a<span class="indexer" data-index="b_c=xeqYk"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|b_c]')), [['<a class="index" href="#index::b_c=KUxv5">a<span class="indexer" data-index="b_c=KUxv5"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|[]]')), [['<a class="index" href="#index::[]">a<span class="indexer" data-index="[]"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|&copy;]')), [['<a class="index" href="#index::&amp;copy;">a<span class="indexer" data-index="&amp;copy;"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a |b]')), [['<a class="index" href="#index::b">a<span class="indexer" data-index="b"></span></a>'], '']);

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 } 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)),
   ([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([
+const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(0, Recursion.terminal, 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),
 ])));
+
+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;
+  }
+}