securemark 0.256.0 → 0.257.0

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

@@ -7,11 +7,9 @@ describe('Unit: parser/inline/bracket', () => {
     const parser = (source: string) => some(bracket)(source, {});
 
     it('(', () => {
-      assert.deepStrictEqual(inspect(parser('(')), [['('], '']);
+      assert.deepStrictEqual(inspect(parser('(')), [['', '('], '']);
       assert.deepStrictEqual(inspect(parser('()')), [['<span class="paren">()</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(a')), [['(', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('(\\a)')), [['<span class="paren">(a)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser(')')), undefined);
+      assert.deepStrictEqual(inspect(parser('(a')), [['', '(', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('(0)')), [['(', '0', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(1)')), [['(', '1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(10)')), [['(', '10', ')'], '']);
@@ -39,6 +37,9 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(Name, Name)')), [['(', 'Name, Name', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(ABBR)')), [['(', 'ABBR', ')'], '']);
       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(')')), undefined);
       assert.deepStrictEqual(inspect(parser('（１，２）')), [['（', '１，２', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（０－１）')), [['（', '０－１', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（０．１）')), [['（', '０．１', '）'], '']);
@@ -49,10 +50,11 @@ describe('Unit: parser/inline/bracket', () => {
     });
 
     it('[', () => {
-      assert.deepStrictEqual(inspect(parser('[')), [['['], '']);
+      assert.deepStrictEqual(inspect(parser('[')), [['', '['], '']);
       assert.deepStrictEqual(inspect(parser('[]')), [['[', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[a')), [['[', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('[a')), [['', '[', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[a]')), [['[', 'a', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[==]')), [['[', '==', ']'], '']);
       assert.deepStrictEqual(inspect(parser(']')), undefined);
     });
 
@@ -61,6 +63,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('{}')), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a')), [['{', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('{a}')), [['{', 'a', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('{==}')), [['{', '==', '}'], '']);
       assert.deepStrictEqual(inspect(parser('}')), undefined);
     });
 
@@ -69,7 +72,8 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('""')), [['"', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"a')), [['"', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('"a"')), [['"', 'a', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(")"')), [['"', '(', '"'], ')"']);
+      assert.deepStrictEqual(inspect(parser('"(")"')), [['"', '', '(', '"'], ')"']);
+      assert.deepStrictEqual(inspect(parser('"(("')), [['"', '((', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"')), [['"', '<span class="paren">(")</span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\\n)"')), [['"', '<span class="paren">(<span class="linebreak"> </span>)</span>', '"'], '']);

package/src/parser/inline/bracket.ts

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

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

@@ -16,12 +16,12 @@ describe('Unit: parser/inline/comment', () => {
       assert.deepStrictEqual(inspect(parser('[% ')), [['[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% \n a')), [['[%', '<br>', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[%%]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[% [%')), [['[%', ' ', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% [%')), [['[%', ' ', '', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% ')), [['[%', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a')), [['[%', ' ', '[%', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a %]')), [['[%', ' ', '<span class="comment"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a[%')), [['[%', ' ', 'a', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [%')), [['[%', ' ', 'a', ' ', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a[%')), [['[%', ' ', 'a', '', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [%')), [['[%', ' ', 'a', ' ', '', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [% ')), [['[%', ' ', 'a', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [% b')), [['[%', ' ', 'a', ' ', '[%', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [%% b')), [['[%', ' ', 'a', ' ', '[%%', ' ', 'b'], '']);
@@ -55,6 +55,7 @@ describe('Unit: parser/inline/comment', () => {
       assert.deepStrictEqual(inspect(parser('[% &a; %]')), [['<span class="comment"><input type="checkbox"><span>[% <span class="invalid">&amp;a;</span> %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% &copy; %]')), [['<span class="comment"><input type="checkbox"><span>[% © %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% &amp;copy; %]')), [['<span class="comment"><input type="checkbox"><span>[% &amp;copy; %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[% [ %]')), [['<span class="comment"><input type="checkbox"><span>[% [ %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% \\ a %]')), [['<span class="comment"><input type="checkbox"><span>[%  a %]</span></span>'], '']);
     });
 

package/src/parser/inline/comment.ts

@@ -1,18 +1,18 @@
 import { CommentParser } from '../inline';
-import { union, some, validate, creator, surround, open, close, match, lazy } from '../../combinator';
+import { union, some, validate, precedence, creator, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
 import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 
-export const comment: CommentParser = lazy(() => creator(validate('[%', match(
+export const comment: CommentParser = lazy(() => validate('[%', creator(precedence(4, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>
     surround(
       open(str(`[${fence}`), some(text, new RegExp(String.raw`^\s+${fence}\]|^\S`)), true),
-      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`)),
+      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 4]]),
       close(some(text, /^\S/), str(`${fence}]`)), true,
       ([as, bs = [], cs], rest) => [[
         html('span', { class: 'comment' }, [
@@ -21,4 +21,4 @@ export const comment: CommentParser = lazy(() => creator(validate('[%', match(
         ]),
       ], rest],
       ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  ([, fence]) => fence.length, [])))));
+  ([, fence]) => fence.length, []))))));

package/src/parser/inline/deletion.ts

@@ -1,12 +1,12 @@
 import { DeletionParser } from '../inline';
-import { union, some, creator, surround, open, lazy } from '../../combinator';
+import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const deletion: DeletionParser = lazy(() => creator(surround(
+export const deletion: DeletionParser = lazy(() => creator(precedence(2, surround(
   str('~~'),
   some(union([
     some(inline, blankWith('\n', '~~')),
@@ -14,4 +14,4 @@ export const deletion: DeletionParser = lazy(() => creator(surround(
   ])),
   str('~~'), false,
   ([, bs], rest) => [[html('del', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

package/src/parser/inline/emphasis.ts

@@ -1,5 +1,5 @@
 import { EmphasisParser } from '../inline';
-import { union, some, creator, surround, open, lazy } from '../../combinator';
+import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { strong } from './strong';
@@ -8,7 +8,7 @@ import { startTight, blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const emphasis: EmphasisParser = lazy(() => creator(surround(
+export const emphasis: EmphasisParser = lazy(() => creator(precedence(1, surround(
   str('*'),
   startTight(some(union([
     strong,
@@ -21,4 +21,4 @@ export const emphasis: EmphasisParser = lazy(() => creator(surround(
   ])), '*'),
   str('*'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

package/src/parser/inline/emstrong.ts

@@ -1,7 +1,6 @@
-import { MarkdownParser } from '../../../markdown';
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Result, IntermediateParser } from '../../combinator/data/parser';
-import { union, some, creator, surround, open, lazy, bind } from '../../combinator';
+import { union, some, precedence, creator, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
@@ -27,14 +26,14 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => creator(surround(
+export const emstrong: EmStrongParser = lazy(() => creator(precedence(1, surround(
   str('***'),
   startTight(some(union([
     some(inline, blankWith('*')),
     open(some(inline, '*'), inline),
   ]))),
   str(/^\*{1,3}/), false,
-  ([, bs, cs], rest, context): Result<HTMLElement | string, MarkdownParser.Context> => {
+  ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
     assert(cs.length === 1);
     switch (cs[0]) {
       case '***':
@@ -58,4 +57,4 @@ export const emstrong: EmStrongParser = lazy(() => creator(surround(
     }
     assert(false);
   },
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

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

@@ -52,6 +52,7 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#\\]]')), [['<a class="index" href="#index:]">]</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#\\\\]')), [['<a class="index" href="#index:\\">\\</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#A]')), [['<a class="index" href="#index:A">A</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#==]')), [['<a class="index" href="#index:==">==</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#*A*]')), [['<a class="index" href="#index:A"><em>A</em></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#`A`]')), [['<a class="index" href="#index:`A`"><code data-src="`A`">A</code></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#${A}$]')), [['<a class="index" href="#index:${A}$"><span class="math" translate="no" data-src="${A}$">${A}$</span></a>'], '']);

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

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, some, validate, guard, context, creator, surround, open, lazy, fmap } from '../../../combinator';
+import { union, some, validate, guard, context, precedence, creator, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str, stropt } from '../../source';
@@ -9,7 +9,7 @@ import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => creator(validate('[#', fmap(indexee(fmap(surround(
+export const index: IndexParser = lazy(() => validate('[#', creator(precedence(3, fmap(indexee(surround(
   '[#',
   guard(context => context.syntax?.inline?.index ?? true,
   startTight(
@@ -25,9 +25,10 @@ export const index: IndexParser = lazy(() => creator(validate('[#', fmap(indexee
   open(stropt(/^\|?/), trimBlankEnd(some(union([
     signature,
     inline,
-  ]), ']', /^\\?\n/)), true)))),
-  ']'),
-  ns => [html('a', defrag(ns))])),
+  ]), ']', [[/^\\?\n/, 9], [']', 3]])), true)))),
+  ']',
+  false,
+  ([, ns], rest) => [[html('a', defrag(ns))], rest])),
   ([el]: [HTMLAnchorElement]) => [
     define(el,
       {
@@ -36,7 +37,7 @@ export const index: IndexParser = lazy(() => creator(validate('[#', fmap(indexee
         href: el.id ? `#${el.id}` : undefined,
       },
       el.childNodes),
-  ]))));
+  ])))));
 
 const signature: IndexParser.SignatureParser = lazy(() => creator(fmap(open(
   '|#',
@@ -49,5 +50,5 @@ const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creator(un
   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('"'), some(txt, '"'), str('"'), true),
+  surround(str('"'), precedence(8, some(txt, '"')), str('"'), true),
 ])));

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

@@ -1,14 +1,12 @@
 import { ExtensionParser } from '../../inline';
-import { union, verify, focus, creator, context, surround, fmap } from '../../../combinator';
+import { union, verify, focus, creator, surround, fmap } from '../../../combinator';
 import { index } from './index';
+import { clean } from '../../util';
 import { html } from 'typed-dom/dom';
 
 export const indexer: ExtensionParser.IndexerParser = creator(fmap(verify(surround(
   /^\s+(?=\[#\S)/,
-  context({ syntax: { inline: {
-    index: true,
-  }}},
-  union([
+  clean(union([
     focus('[#]', () => [[html('a', { href: '#' })], '']),
     index,
   ])),

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

@@ -11,7 +11,7 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(validate
   body,
 ])));
 
-export const label: ExtensionParser.LabelParser = creator(validate(['[$', '$'], fmap(
+export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creator(fmap(
   guard(context => context.syntax?.inline?.label ?? true,
   union([
     surround('[', body, ']'),

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

@@ -45,6 +45,7 @@ describe('Unit: parser/inline/extension/placeholder', () => {
       assert.deepStrictEqual(inspect(parser('[^a\\ \\ ]')), [['<span class="invalid">a  </span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a<wbr>]')), [['<span class="invalid">a<wbr></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a<wbr><wbr>]')), [['<span class="invalid">a<wbr><wbr></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^==]')), [['<span class="invalid">==</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a[% b %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a[% b %][% c %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span><span class="comment"><input type="checkbox"><span>[% c %]</span></span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^\\]]')), [['<span class="invalid">]</span>'], '']);

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

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../inline';
-import { union, some, validate, creator, surround, lazy } from '../../../combinator';
+import { union, some, validate, precedence, creator, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { startTight } from '../../util';
@@ -10,9 +10,9 @@ import { unshift } from 'spica/array';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => creator(validate(['[:', '[^'], surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], creator(precedence(3, surround(
   str(/^\[[:^]/),
-  startTight(some(union([inline]), ']', /^\\?\n/)),
+  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 3]])),
   str(']'), false,
   ([as, bs], rest) => [[
     html('span', {
@@ -22,4 +22,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => creator
       'data-invalid-message': `Reserved start symbol "${as[0][1]}" cannot be used in "[]"`,
     }, defrag(bs)),
   ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])))));

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

@@ -25,6 +25,7 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<a,b>')), undefined);
       assert.deepStrictEqual(inspect(parser('<a, b>')), undefined);
       assert.deepStrictEqual(inspect(parser('<T>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdi>')), [['<span class="invalid">&lt;bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>z')), [['<span class="invalid">&lt;bdi&gt;z</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi></bdi>')), [['<span class="invalid">&lt;bdi&gt;&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi> </bdi>')), [['<span class="invalid">&lt;bdi&gt; &lt;/bdi&gt;</span>'], '']);
@@ -76,6 +77,7 @@ describe('Unit: parser/inline/html', () => {
     });
 
     it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('<bdi>[% </bdi>')), [['<bdi>[% </bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi><bdi>a</bdi></bdi>')), [['<bdi><bdi>a</bdi></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a<bdi>b</bdi>c</bdi>')), [['<bdi>a<bdi>b</bdi>c</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>`a`</bdi>')), [['<bdi><code data-src="`a`">a</code></bdi>'], '']);

package/src/parser/inline/html.ts

@@ -1,6 +1,6 @@
 import { undefined, Object } from 'spica/global';
 import { HTMLParser } from '../inline';
-import { union, subsequence, some, validate, focus, creator, surround, open, match, lazy } from '../../combinator';
+import { union, subsequence, some, validate, focus, precedence, creator, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { isStartLooseNodes, blankWith } from '../util';
@@ -18,7 +18,7 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, creator(precedence(5, union([
   focus(
     '<wbr>',
     () => [[h('wbr')], '']),
@@ -34,7 +34,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`)), true)),
+          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 5]]), true)),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
@@ -50,7 +50,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(inline, `</${tag}>`),
+          some(inline, `</${tag}>`, [[`</${tag}>`, 5]]),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
@@ -59,7 +59,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
           [[elem(tag, as, bs, [])], rest]),
     ([, tag]) => tag,
     new Cache(10000))),
-])))));
+]))))));
 
 export const attribute: HTMLParser.TagParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/),

package/src/parser/inline/insertion.ts

@@ -1,12 +1,12 @@
 import { InsertionParser } from '../inline';
-import { union, some, creator, surround, open, lazy } from '../../combinator';
+import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const insertion: InsertionParser = lazy(() => creator(surround(
+export const insertion: InsertionParser = lazy(() => creator(precedence(2, surround(
   str('++'),
   some(union([
     some(inline, blankWith('\n', '++')),
@@ -14,4 +14,4 @@ export const insertion: InsertionParser = lazy(() => creator(surround(
   ])),
   str('++'), false,
   ([, bs], rest) => [[html('ins', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

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

@@ -151,6 +151,7 @@ describe('Unit: parser/inline/link', () => {
     });
 
     it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('[*]{/}')), [['<a href="/">*</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[\\[]{/}')), [['<a href="/">[</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[\\]]{/}')), [['<a href="/">]</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[]{a}]{a}')), [['<a href="a">[]{a}</a>'], '']);

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { undefined, location, encodeURI, decodeURI, Location } from 'spica/global';
 import { LinkParser } from '../inline';
 import { eval } from '../../combinator/data/parser';
-import { union, inits, tails, some, validate, guard, context, creator, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, validate, guard, context, precedence, creator, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { autolink } from '../autolink';
@@ -15,7 +15,7 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], bind(
+export const link: LinkParser = lazy(() => validate(['[', '{'], creator(10, precedence(3, bind(
   guard(context => context.syntax?.inline?.link ?? true,
   reverse(tails([
     context({ syntax: { inline: {
@@ -36,7 +36,7 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], bind
           media: false,
           autolink: false,
         }}},
-        trimBlankStart(some(inline, ']', /^\\?\n/))),
+        trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 3]]))),
         ']',
         true),
     ]))),
@@ -60,7 +60,7 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], bind
     if (el.classList.contains('invalid')) return [[el], rest];
     assert(el.classList.length === 0);
     return [[define(el, attributes('link', [], optspec, params))], rest];
-  }))));
+  })))));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
   open(/^[^\S\n]+/, str(/^\S+/)),
@@ -90,8 +90,8 @@ export function resolve(uri: string, host: URL | Location, source: URL | Locatio
     default:
       const target = new ReadonlyURL(uri, source.href);
       return target.origin === host.origin
-          ? target.href.slice(target.origin.length)
-          : target.href;
+        ? target.href.slice(target.origin.length)
+        : target.href;
   }
 }
 

package/src/parser/inline/mark.ts

@@ -1,12 +1,12 @@
 import { MarkParser } from '../inline';
-import { union, some, creator, surround, open, lazy } from '../../combinator';
+import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { startTight, blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const mark: MarkParser = lazy(() => creator(surround(
+export const mark: MarkParser = lazy(() => creator(precedence(2, surround(
   str('=='),
   startTight(some(union([
     some(inline, blankWith('==')),
@@ -14,4 +14,4 @@ export const mark: MarkParser = lazy(() => creator(surround(
   ]))),
   str('=='), false,
   ([, bs], rest) => [[html('mark', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

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

@@ -18,6 +18,12 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$-a $-b')), undefined);
       assert.deepStrictEqual(inspect(parser('$-a\\ $-b')), undefined);
       assert.deepStrictEqual(inspect(parser('$a $')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a `$`')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a ``$``')), undefined);
+      // (``" + ``" + $-b") or (``"`` + "$-b")
+      assert.deepStrictEqual(inspect(parser('$-a ``"``"$-b"')), undefined);
+      // (``b`` + "c" + $-d) or (``b``"c" + $-d)
+      assert.deepStrictEqual(inspect(parser('$-a ``b``"c"$-d')), undefined);
       assert.deepStrictEqual(inspect(parser('$-a"$-b"')), undefined);
       assert.deepStrictEqual(inspect(parser('$-a\\"$-b\\"')), undefined);
       assert.deepStrictEqual(inspect(parser('$a"$')), undefined);
@@ -28,7 +34,6 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$-a\\[$-b\\]')), undefined);
       assert.deepStrictEqual(inspect(parser('$a[$')), undefined);
       assert.deepStrictEqual(inspect(parser('$-a{$-b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('$-a\\{$-b\\}')), undefined);
       assert.deepStrictEqual(inspect(parser('$a{$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a$b')), undefined);
       assert.deepStrictEqual(inspect(parser('$a$b$')), undefined);
@@ -38,13 +43,25 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$\n$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a\\$\nb$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a\\$\\\nb$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$`"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$`$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$`a"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$`a"b$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``$"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a$')), undefined);
       assert.deepStrictEqual(inspect(parser('$``a"$0')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a""b$')), undefined);
       assert.deepStrictEqual(inspect(parser('$``a""$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$```a"$')), undefined);
       assert.deepStrictEqual(inspect(parser('$```a""$')), undefined);
       assert.deepStrictEqual(inspect(parser('$``\n"$')), undefined);
       assert.deepStrictEqual(inspect(parser('$``a\\$\nb"$')), undefined);
       assert.deepStrictEqual(inspect(parser('$``a\\$\\\nb"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``\\"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a``b"c"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$````""$')), undefined);
       assert.deepStrictEqual(inspect(parser('$"$')), undefined);
       assert.deepStrictEqual(inspect(parser('$}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${')), undefined);
@@ -104,18 +121,8 @@ describe('Unit: parser/inline/math', () => {
       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>'], '']);
       assert.deepStrictEqual(inspect(parser('$k$-space')), [['<span class="math" translate="no" data-src="$k$">$k$</span>'], '-space']);
-      assert.deepStrictEqual(inspect(parser('$`$')), [['<span class="math" translate="no" data-src="$`$">$`$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$`"a$')), [['<span class="math" translate="no" data-src="$`&quot;a$">$`"a$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$``$')), [['<span class="math" translate="no" data-src="$``$">$``$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$``"$')), [['<span class="math" translate="no" data-src="$``&quot;$">$``"$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$``""a$')), [['<span class="math" translate="no" data-src="$``&quot;&quot;a$">$``""a$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$``a"$')), [['<span class="math" translate="no" data-src="$``a&quot;$">$``a"$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$``$"$')), [['<span class="math" translate="no" data-src="$``$">$``$</span>'], '"$']);
-      assert.deepStrictEqual(inspect(parser('$``\\"$')), [['<span class="math" translate="no" data-src="$``\\&quot;$">$``\\"$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$``a``b"c"$')), [['<span class="math" translate="no" data-src="$``a``b&quot;c&quot;$">$``a``b"c"$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$```"$')), [['<span class="math" translate="no" data-src="$```&quot;$">$```"$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$````""$')), [['<span class="math" translate="no" data-src="$````&quot;&quot;$">$````""$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$a{b}$')), [['<span class="math" translate="no" data-src="$a{b}$">$a{b}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$a\\{$\\}')), [['<span class="math" translate="no" data-src="$a\\{$">$a\\{$</span>'], '\\}']);
       assert.deepStrictEqual(inspect(parser('${}$')), [['<span class="math" translate="no" data-src="${}$">${}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${ }$')), [['<span class="math" translate="no" data-src="${ }$">${ }$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${a}$')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '']);
@@ -127,7 +134,7 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('${a }$')), [['<span class="math" translate="no" data-src="${a }$">${a }$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${ a}$')), [['<span class="math" translate="no" data-src="${ a}$">${ a}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${ a }$')), [['<span class="math" translate="no" data-src="${ a }$">${ a }$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('${``a"}$')), [['<span class="math" translate="no" data-src="${``a&quot;}$">${``a"}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${``"}$')), [['<span class="math" translate="no" data-src="${``&quot;}$">${``"}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\a}$')), [['<span class="math" translate="no" data-src="${\\a}$">${\\a}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\$}$')), [['<span class="math" translate="no" data-src="${\\$}$">${\\$}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\\\}$')), [['<span class="math" translate="no" data-src="${\\\\}$">${\\\\}$</span>'], '']);