securemark 0.257.1 → 0.258.0

package/src/combinator.ts

@@ -4,14 +4,13 @@ export * from './combinator/data/parser/tails';
 export * from './combinator/data/parser/sequence';
 export * from './combinator/data/parser/subsequence';
 export * from './combinator/data/parser/some';
+export * from './combinator/data/parser/context';
 export * from './combinator/control/constraint/block';
 export * from './combinator/control/constraint/line';
 export * from './combinator/control/constraint/contract';
 export * from './combinator/control/manipulation/fence';
 export * from './combinator/control/manipulation/indent';
 export * from './combinator/control/manipulation/scope';
-export * from './combinator/control/manipulation/context';
-export * from './combinator/control/manipulation/resource';
 export * from './combinator/control/manipulation/surround';
 export * from './combinator/control/manipulation/match';
 export * from './combinator/control/manipulation/convert';

package/src/parser/api/bind.ts

@@ -2,9 +2,10 @@ import { undefined, location } from 'spica/global';
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
+import { segment, validate, MAX_INPUT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
-import { segment, validate, MAX_INPUT_SIZE } from '../segment';
+import { backtrackable } from '../context';
 import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
@@ -23,6 +24,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   let context: MarkdownParser.Context = {
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
+    backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   assert(!settings.id);
@@ -141,8 +143,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
 
   function nearest(index: number): HTMLElement | undefined {
     let el: HTMLElement | undefined;
-    let len = 0;
-    for (let i = 0; i < blocks.length; ++i) {
+    for (let i = 0, len = 0; i < blocks.length; ++i) {
       const block = blocks[i];
       len += block[0].length;
       el = block[1][0] ?? el;
@@ -152,8 +153,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   }
 
   function index(source: HTMLElement): number {
-    let len = 0;
-    for (let i = 0; i < blocks.length; ++i) {
+    for (let i = 0, len = 0; i < blocks.length; ++i) {
       const block = blocks[i];
       if (block[1].includes(source)) return len;
       len += block[0].length;

package/src/parser/api/parse.ts

@@ -2,9 +2,10 @@ import { location } from 'spica/global';
 import { ParserOptions } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
+import { segment, validate, MAX_SEGMENT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
-import { segment, validate, MAX_SEGMENT_SIZE } from '../segment';
+import { backtrackable } from '../context';
 import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
@@ -29,6 +30,7 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
     ...context?.resources && {
       resources: context.resources,
     },
+    backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   const node = frag();

package/src/parser/block/blockquote.ts

@@ -1,5 +1,5 @@
 import { BlockquoteParser } from '../block';
-import { union, some, block, validate, rewrite, creator, open, convert, lazy, fmap } from '../../combinator';
+import { union, some, creator, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { parse } from '../api/parse';

package/src/parser/block/dlist.ts

@@ -1,23 +1,17 @@
 import { DListParser } from '../block';
-import { union, inits, some, block, line, validate, rewrite, context, creator, open, trimEnd, lazy, fmap } from '../../combinator';
+import { union, inits, some, creator, state, block, line, validate, rewrite, open, trimEnd, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer } from '../inline';
 import { anyline } from '../source';
+import { State } from '../context';
 import { localize } from '../locale';
-import { visualize, trimBlank } from '../util';
+import { visualize, trimBlank } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { push } from 'spica/array';
 
 export const dlist: DListParser = lazy(() => block(localize(fmap(validate(
   /^~[^\S\n]+(?=\S)/,
   some(inits([
-    context({ syntax: { inline: {
-      annotation: false,
-      reference: false,
-      index: false,
-      label: false,
-      link: false,
-      media: false,
-    }}},
+    state(State.annotation | State.reference | State.index | State.label | State.link | State.media,
     some(term)),
     some(desc),
   ]))),

package/src/parser/block/extension/figure.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../block';
-import { union, inits, sequence, some, block, line, fence, rewrite, context, close, match, convert, trimEnd, fallback, fmap } from '../../../combinator';
+import { union, inits, sequence, some, state, block, line, fence, rewrite, close, match, convert, trimEnd, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
 import { label, segment as seg_label } from '../../inline/extension/label';
 import { ulist } from '../ulist';
@@ -13,8 +13,9 @@ import { table, segment_ as seg_table } from './table';
 import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
 import { inline, media, shortmedia } from '../../inline';
+import { State } from '../../context';
 import { localize } from '../../locale';
-import { visualize, trimBlank } from '../../util';
+import { visualize, trimBlank } from '../../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 
@@ -66,7 +67,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
       ])),
       emptyline,
       block(localize(
-        context({ syntax: { inline: { media: false } } },
+        state(State.media,
         visualize(trimBlank(trimEnd(some(inline))))))),
     ]),
   ])),

package/src/parser/block/extension/table.ts

@@ -2,11 +2,11 @@ import { undefined, BigInt, Array } from 'spica/global';
 import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
 import { Tree, eval } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, block, line, validate, fence, rewrite, creator, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
+import { union, subsequence, inits, some, creator, block, line, validate, fence, rewrite, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { localize } from '../../locale';
-import { visualize } from '../../util';
+import { visualize } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 import { unshift, splice } from 'spica/array';
 

package/src/parser/block/heading.ts

@@ -1,8 +1,9 @@
 import { HeadingParser } from '../block';
-import { union, some, block, line, validate, focus, rewrite, context, open, fmap } from '../../combinator';
+import { union, some, state, block, line, validate, focus, rewrite, open, fmap } from '../../combinator';
 import { inline, indexee, indexer } from '../inline';
 import { str } from '../source';
-import { visualize, trimBlank } from '../util';
+import { State } from '../context';
+import { visualize, trimBlank } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
@@ -10,23 +11,14 @@ export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
   some(line(source => [[source], ''])))));
 
 export const heading: HeadingParser = block(rewrite(segment,
-  context({ syntax: { inline: {
-    annotation: false,
-    reference: false,
-    index: false,
-    label: false,
-    link: false,
-    media: false,
-  }}},
+  state(State.annotation | State.reference | State.index | State.label | State.link | State.media,
   line(indexee(fmap(union([
     open(
       str(/^##+/),
       visualize(trimBlank(some(union([indexer, inline])))), true),
     open(
       str('#'),
-      context({ syntax: { inline: {
-        autolink: false,
-      }}},
+      state(State.autolink,
       visualize(trimBlank(some(union([indexer, inline]))))), true),
   ]),
   ([h, ...ns]: [string, ...(HTMLElement | string)[]]) => [

package/src/parser/block/ilist.ts

@@ -1,13 +1,14 @@
 import { IListParser } from '../block';
-import { union, inits, some, block, line, validate, indent, context, creator, open, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, some, creator, state, block, line, validate, indent, open, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, fillFirstLine } from './ulist';
 import { olist_, invalid } from './olist';
 import { inline } from '../inline';
+import { State } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ilist: IListParser = lazy(() => block(validate(
   /^[-+*](?=[^\S\n]|\n[^\S\n]*\S)/,
-  context({ syntax: { inline: { media: false } } },
+  state(State.media,
   ilist_))));
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(

package/src/parser/block/olist.ts

@@ -1,13 +1,15 @@
 import { undefined } from 'spica/global';
 import { OListParser } from '../block';
-import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, match, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, creator, state, block, line, validate, indent, focus, rewrite, open, match, fallback, lazy, fmap } from '../../combinator';
 import { checkbox, ulist_, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
 import { inline, indexee, indexer } from '../inline';
 import { contentline } from '../source';
-import { trimBlank } from '../util';
+import { State } from '../context';
+import { trimBlank } from '../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
+import { duffbk } from 'spica/duff';
 import { shift } from 'spica/array';
 import { tuple } from 'spica/tuple';
 
@@ -21,7 +23,7 @@ export const olist: OListParser = lazy(() => block(validate(
     /^([0-9]+|[a-z]+|[A-Z]+)(?:-[0-9]+)*\.(?=[^\S\n]|\n[^\S\n]*\S)/.source,
     /^\(([0-9]+|[a-z]+)\)(?:-[0-9]+)*(?=[^\S\n]|\n[^\S\n]*\S)/.source,
   ].join('|')),
-  context({ syntax: { inline: { media: false } } },
+  state(State.media,
   olist_))));
 
 export const olist_: OListParser = lazy(() => block(union([
@@ -122,15 +124,16 @@ function format(el: HTMLOListElement, type: string, form: string): HTMLOListElem
     'data-type': style(type) || undefined,
   });
   const marker = el.firstElementChild?.getAttribute('data-marker')!.match(initial(type))?.[0] ?? '';
-  for (let es = el.children, len = es.length, i = 0; i < len; ++i) {
+  const es = el.children;
+  duffbk(es.length, i => {
     const el = es[i];
     switch (el.getAttribute('data-marker')) {
       case '':
       case marker:
         el.removeAttribute('data-marker');
-        continue;
+        return;
     }
-    break;
-  }
+    return false;
+  });
   return el;
 }

package/src/parser/block/paragraph.ts

@@ -2,7 +2,7 @@ import { ParagraphParser } from '../block';
 import { union, some, block, trimEnd, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { localize } from '../locale';
-import { visualize } from '../util';
+import { visualize } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
 export const paragraph: ParagraphParser = block(localize(fmap(

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

@@ -1,5 +1,5 @@
 import { ReplyParser } from '../../block';
-import { union, tails, line, validate, focus, creator, reverse, fmap } from '../../../combinator';
+import { union, tails, creator, 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';

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

@@ -1,6 +1,6 @@
 import { ReplyParser } from '../../block';
 import { eval } from '../../../combinator/data/parser';
-import { union, some, block, line, validate, rewrite, creator, lazy, fmap } from '../../../combinator';
+import { union, some, creator, block, line, validate, rewrite, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { str, anyline } from '../../source';
 import { autolink } from '../../autolink';

package/src/parser/block/reply.ts

@@ -5,7 +5,7 @@ import { quote, syntax as delimiter } from './reply/quote';
 import { inline } from '../inline';
 import { anyline } from '../source';
 import { localize } from '../locale';
-import { visualize } from '../util';
+import { visualize } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { push, pop } from 'spica/array';
 

package/src/parser/block/sidefence.ts

@@ -1,5 +1,5 @@
 import { SidefenceParser } from '../block';
-import { union, some, block, focus, rewrite, creator, convert, lazy, fmap } from '../../combinator';
+import { union, some, creator, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { html, define, defrag } from 'typed-dom/dom';

package/src/parser/block/table.test.ts

@@ -29,6 +29,11 @@ describe('Unit: parser/block/table', () => {
       assert.deepStrictEqual(inspect(parser('|\n|-\n|')), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('||\n|-|\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|||\n|-|-|\n|||')), [['<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|"|\n|-\n|')), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|`|\n|-\n|')), [['<table><thead><tr><th>`</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|`|`|\n|-\n|')), [['<table><thead><tr><th><code data-src="`|`">|</code></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|((|\n|-\n|')), [['<table><thead><tr><th>((</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|${|\n|-\n|')), [['<table><thead><tr><th>${</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|b|\n|-|-|\n|1|2|')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|b\n|-|-\n|1|2')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|\n|-|\n|1|')), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);

package/src/parser/block/table.ts

@@ -1,8 +1,10 @@
 import { TableParser } from '../block';
-import { union, sequence, some, block, line, validate, focus, rewrite, creator, surround, open, fallback, lazy, fmap } from '../../combinator';
+import { union, sequence, some, creator, block, line, validate, focus, rewrite, surround, open, fallback, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { contentline } from '../source';
+import { trimNode } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
+import { duffEach, duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 
 import RowParser = TableParser.RowParser;
@@ -24,7 +26,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
   ])));
 
 const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creator(fallback(fmap(
-  line(surround(/^(?=\|)/, some(union([parser])), /^\|?\s*$/, optional)),
+  line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
   es => [html('tr', es)]),
   rewrite(contentline, source => [[
     html('tr', {
@@ -46,31 +48,30 @@ const align: AlignParser = creator(fmap(open(
   ns => [html('td', defrag(ns))]));
 
 const cell: CellParser = surround(
-  /^\|(?:\\?\s)*(?=\S)/,
-  some(union([inline]), /^(?:\\?\s)*(?=\||\\?$)/),
+  /^\|\s*(?=\S)/,
+  some(union([inline]), /^\|/, [[/^[|\\]?\s*$/, 9]]),
   /^[^|]*/, true);
 
 const head: CellParser.HeadParser = creator(fmap(
   cell,
-  ns => [html('th', defrag(ns))]));
+  ns => [html('th', trimNode(defrag(ns)))]));
 
 const data: CellParser.DataParser = creator(fmap(
   cell,
-  ns => [html('td', defrag(ns))]));
+  ns => [html('td', trimNode(defrag(ns)))]));
 
 function format(rows: HTMLTableRowElement[]): HTMLTableRowElement[] {
   const aligns = rows[0].classList.contains('invalid')
     ? []
-    : push([], rows.shift()!.children).map(el => el.textContent!);
-  for (let i = 0, len = rows.length; i < len; ++i) {
-    const cols = rows[i].children;
-    for (let i = 0, len = cols.length; i < len; ++i) {
+    : duffReduce(rows.shift()!.children, (acc, el) => push(acc, [el.textContent!]), [] as string[]);
+  for (let i = 0; i < rows.length; ++i) {
+    duffEach(rows[i].children, (col, i) => {
       if (i > 0 && !aligns[i]) {
         aligns[i] = aligns[i - 1];
       }
-      if (!aligns[i]) continue;
-      cols[i].setAttribute('align', aligns[i]);
-    }
+      if (!aligns[i]) return;
+      col.setAttribute('align', aligns[i]);
+    });
   }
   return rows;
 }

package/src/parser/block/ulist.ts

@@ -1,15 +1,16 @@
 import { UListParser } from '../block';
-import { union, inits, subsequence, some, block, line, validate, indent, focus, context, creator, open, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, creator, state, block, line, validate, indent, focus, open, fallback, lazy, fmap } from '../../combinator';
 import { olist_, invalid } from './olist';
 import { ilist_ } from './ilist';
 import { inline, indexer, indexee } from '../inline';
-import { trimBlank } from '../util';
+import { State } from '../context';
+import { trimBlank } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const ulist: UListParser = lazy(() => block(validate(
   /^-(?=[^\S\n]|\n[^\S\n]*\S)/,
-  context({ syntax: { inline: { media: false } } },
+  state(State.media,
   ulist_))));
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(

package/src/parser/block.ts

@@ -36,7 +36,7 @@ export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
 export const block: BlockParser = creator(error(
-  reset({ resources: { budget: 50 * 1000, recursion: 20 + 1 } },
+  reset({ resources: { budget: 50 * 1000, recursion: 20 } },
   union([
     emptyline,
     horizontalrule,

package/src/parser/context.ts

@@ -0,0 +1,32 @@
+export const enum Rule {
+  reference = 1 << 12,
+  comment = 1 << 11,
+  index = 1 << 10,
+  placeholder = 1 << 9,
+  link = 1 << 8,
+  bracket = 1 << 7,
+  media = 1 << 6,
+  annotation = 1 << 5,
+  mathbracket = 1 << 4,
+  html = 1 << 3,
+  math = 1 << 2,
+  autolink = 1 << 1,
+  quote = 1 << 0,
+  none = 0,
+}
+export const backtrackable = 0
+  | Rule.annotation
+  | Rule.reference
+  | Rule.index
+  | Rule.link
+  | Rule.media;
+
+export const enum State {
+  annotation = 1 << 6,
+  reference = 1 << 5,
+  index = 1 << 4,
+  label = 1 << 3,
+  link = 1 << 2,
+  media = 1 << 1,
+  autolink = 1 << 0,
+}

package/src/parser/header.ts

@@ -1,5 +1,5 @@
 import { MarkdownParser } from '../../markdown';
-import { union, inits, some, block, line, validate, focus, rewrite, guard, clear, convert, lazy, fmap } from '../combinator';
+import { union, inits, some, guard, block, line, validate, focus, rewrite, clear, convert, lazy, fmap } from '../combinator';
 import { segment } from './segment';
 import { str } from './source';
 import { normalize } from './api/normalize';

package/src/parser/inline/annotation.ts

@@ -1,28 +1,20 @@
 import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
-import { union, some, validate, guard, context, precedence, creator, recursion, surround, lazy } from '../../combinator';
+import { union, some, guard, context, syntax, state, validate, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
-import { startLoose, trimNode } from '../util';
+import { Rule, State } from '../context';
+import { startLoose, trimNode } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const annotation: AnnotationParser = lazy(() => creator(recursion(precedence(6, validate('((', surround(
+export const annotation: AnnotationParser = lazy(() => validate('((', syntax(Rule.annotation, 6, surround(
   '((',
-  guard(context => context.syntax?.inline?.annotation ?? true,
+  guard(context => ~context.state! & State.annotation,
+  state(State.annotation | State.media,
   startLoose(
-  context({ syntax: { inline: {
-    annotation: false,
-    // Redundant
-    //reference: true,
-    media: false,
-    // Redundant
-    //index: true,
-    //label: true,
-    //link: true,
-    //autolink: true,
-  }}, delimiters: undefined },
-  some(union([inline]), ')', [[/^\\?\n/, 9], [')', 3], ['))', 6]])), ')')),
+  context({ delimiters: undefined },
+  some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2], ['))', 6]])), ')'))),
   '))',
   false,
   ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNode(defrag(ns)))])], rest],
-  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest)))))));
+  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest)))));

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

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { verify, rewrite, creator } from '../../../combinator';
+import { creator, verify, rewrite } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 

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

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { union, some, validate, focus, rewrite, precedence, creator, convert, surround, open, lazy } from '../../../combinator';
+import { union, some, creator, precedence, validate, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
 import { textlink } from '../link';
 import { unescsource } from '../../source';
 
@@ -13,7 +13,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'ht
     url => `{ ${url} }`,
     union([textlink])))));
 
-const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(precedence(3, union([
+const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(precedence(2, union([
   surround('(', some(union([bracket, unescsource]), ')'), ')', true),
   surround('[', some(union([bracket, unescsource]), ']'), ']', true),
   surround('{', some(union([bracket, unescsource]), '}'), '}', true),

package/src/parser/inline/autolink.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../inline';
-import { union, some, validate, guard, fmap } from '../../combinator';
+import { union, some, syntax, guard, validate, fmap } from '../../combinator';
 import { url } from './autolink/url';
 import { email } from './autolink/email';
 import { channel } from './autolink/channel';
@@ -8,11 +8,13 @@ import { hashtag, emoji } from './autolink/hashtag';
 import { hashnum } from './autolink/hashnum';
 import { anchor } from './autolink/anchor';
 import { str } from '../source';
+import { Rule, State } from '../context';
 import { stringify } from '../util';
 
 export const autolink: AutolinkParser = fmap(
   validate(/^(?:[@#>0-9A-Za-z]|\S#)/,
-  guard(context => context.syntax?.inline?.autolink ?? true,
+  guard(context => ~context.state! & State.autolink,
+  syntax(Rule.autolink, 1,
   some(union([
     url,
     email,
@@ -29,5 +31,5 @@ export const autolink: AutolinkParser = fmap(
     // Escape unmatched hashtag-like strings.
     str(new RegExp(/^#+(?:[^\p{C}\p{S}\p{P}\s]|emoji|['_])*/u.source.replace('emoji', emoji), 'u')),
     anchor,
-  ])))),
+  ]))))),
   ns => ns.length === 1 ? ns : [stringify(ns)]);

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

@@ -39,6 +39,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(ABBR, ABBR)')), [['(', 'ABBR, ABBR', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(\\a)')), [['<span class="paren">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(==)')), [['<span class="paren">(==)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('($)$')), [['', '(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(')')), undefined);
       assert.deepStrictEqual(inspect(parser('（１，２）')), [['（', '１，２', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（０－１）')), [['（', '０－１', '）'], '']);
@@ -55,6 +56,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('[a')), [['', '[', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[a]')), [['[', 'a', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[==]')), [['[', '==', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[$]$')), [['', '[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(']')), undefined);
     });
 

package/src/parser/inline/bracket.ts

@@ -1,30 +1,31 @@
 import { undefined } from 'spica/global';
 import { BracketParser } from '../inline';
-import { union, some, precedence, creator, surround, lazy } from '../../combinator';
+import { union, some, syntax, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
+import { Rule } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
-export const bracket: BracketParser = lazy(() => creator(0, union([
-  surround(str('('), precedence(3, str(index)), str(')')),
-  surround(str('('), precedence(3, some(inline, ')', [[')', 3]])), str(')'), true,
+export const bracket: BracketParser = lazy(() => union([
+  syntax(Rule.none, 2, surround(str('('), str(index), str(')'))),
+  syntax(Rule.bracket, 2, surround(str('('), some(inline, ')', [[')', 2]]), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
-  surround(str('（'), precedence(3, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
-  surround(str('（'), precedence(3, some(inline, '）', [['）', 3]])), str('）'), true,
+    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest])),
+  syntax(Rule.none, 2, surround(str('（'), str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))), str('）'))),
+  syntax(Rule.bracket, 2, surround(str('（'), some(inline, '）', [['）', 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('['), precedence(3, some(inline, ']', [[']', 3]])), str(']'), true,
+    ([as, bs = []], rest) => [unshift(as, bs), rest])),
+  syntax(Rule.bracket, 2, surround(str('['), some(inline, ']', [[']', 2]]), str(']'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
-  surround(str('{'), precedence(3, some(inline, '}', [['}', 3]])), str('}'), true,
+    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest])),
+  syntax(Rule.bracket, 2, surround(str('{'), some(inline, '}', [['}', 2]]), str('}'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    ([as, bs = []], rest) => [unshift(as, bs), rest])),
   // Control media blinking in editing rather than control confusion of pairs of quote marks.
-  surround(str('"'), precedence(8, some(inline, '"', [['"', 8]])), str('"'), true,
+  syntax(Rule.quote, 8, surround(str('"'), some(inline, '"', [['"', 8]]), str('"'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
-])));
+    ([as, bs = []], rest) => [unshift(as, bs), rest])),
+]));

package/src/parser/inline/code.ts

@@ -1,5 +1,5 @@
 import { CodeParser } from '../inline';
-import { validate, creator, match } from '../../combinator';
+import { creator, validate, match } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
 export const code: CodeParser = creator(validate('`', match(