securemark 0.255.1 → 0.257.1

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

@@ -14,14 +14,15 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('(())')), undefined);
       assert.deepStrictEqual(inspect(parser('(()))')), undefined);
       assert.deepStrictEqual(inspect(parser('(( ))')), undefined);
+      assert.deepStrictEqual(inspect(parser('(( (a')), [['', '(('], ' (a']);
       assert.deepStrictEqual(inspect(parser('((\n))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\na))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\\na))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\n))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\\\n))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\nb))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\n))')), [['', '(('], 'a\n))']);
+      assert.deepStrictEqual(inspect(parser('((a\\\n))')), [['', '(('], 'a\\\n))']);
+      assert.deepStrictEqual(inspect(parser('((a\nb))')), [['', '(('], 'a\nb))']);
+      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), [['', '(('], 'a\\\nb))']);
+      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), [['', '(('], '*a\nb*))']);
       assert.deepStrictEqual(inspect(parser('((\\))')), undefined);
       assert.deepStrictEqual(inspect(parser('((a)b))')), undefined);
       assert.deepStrictEqual(inspect(parser('(((a))')), undefined);
@@ -42,6 +43,7 @@ describe('Unit: parser/inline/annotation', () => {
     });
 
     it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((`a`))')), [['<sup class="annotation"><span><code data-src="`a`">a</code></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((@a))')), [['<sup class="annotation"><span><a href="/@a" class="account">@a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((http://host))')), [['<sup class="annotation"><span><a href="http://host" target="_blank">http://host</a></span></sup>'], '']);

package/src/parser/inline/annotation.ts

@@ -1,13 +1,15 @@
 import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
-import { union, some, validate, guard, context, creator, surround, lazy, fmap } from '../../combinator';
+import { union, some, validate, guard, context, precedence, creator, recursion, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { trimBlank } from '../util';
+import { optimize } from './link';
+import { startLoose, trimNode } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const annotation: AnnotationParser = lazy(() => creator(validate('((', '))', '\n', fmap(surround(
+export const annotation: AnnotationParser = lazy(() => creator(recursion(precedence(6, validate('((', surround(
   '((',
   guard(context => context.syntax?.inline?.annotation ?? true,
+  startLoose(
   context({ syntax: { inline: {
     annotation: false,
     // Redundant
@@ -19,6 +21,8 @@ export const annotation: AnnotationParser = lazy(() => creator(validate('((', ')
     //link: true,
     //autolink: true,
   }}, delimiters: undefined },
-  trimBlank(some(union([inline]), ')', /^\\?\n/)))),
-  '))'),
-  ns => [html('sup', { class: 'annotation' }, [html('span', defrag(ns))])]))));
+  some(union([inline]), ')', [[/^\\?\n/, 9], [')', 3], ['))', 6]])), ')')),
+  '))',
+  false,
+  ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNode(defrag(ns)))])], rest],
+  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest)))))));

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

@@ -1,6 +1,6 @@
 import { AutolinkParser } from '../../inline';
-import { union, tails, verify, rewrite, context, open, convert, fmap, lazy } from '../../../combinator';
-import { link } from '../link';
+import { union, tails, verify, rewrite, open, convert, fmap, lazy } from '../../../combinator';
+import { textlink } from '../link';
 import { str } from '../../source';
 import { define } from 'typed-dom/dom';
 
@@ -17,10 +17,6 @@ export const account: AutolinkParser.AccountParser = lazy(() => fmap(rewrite(
         str(/^[A-Za-z][0-9A-Za-z]*(?:-[0-9A-Za-z]+)*/),
         ([source]) => source.length <= 64),
     ])),
-  context({ syntax: { inline: {
-    link: true,
-    autolink: false,
-  }}},
   convert(
     source =>
       `[${source}]{ ${
@@ -28,5 +24,5 @@ export const account: AutolinkParser.AccountParser = lazy(() => fmap(rewrite(
         ? `https://${source.slice(1).replace('/', '/@')}`
         : `/${source}`
       } }`,
-    union([link])))),
+    union([textlink]))),
   ([el]) => [define(el, { class: 'account' })]));

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

@@ -1,6 +1,6 @@
 import { AutolinkParser } from '../../inline';
-import { union, validate, focus, context, convert, fmap, lazy } from '../../../combinator';
-import { link } from '../link';
+import { union, validate, focus, convert, fmap, lazy } from '../../../combinator';
+import { textlink } from '../link';
 import { define } from 'typed-dom/dom';
 
 // Timeline(pseudonym): user/tid
@@ -14,10 +14,6 @@ import { define } from 'typed-dom/dom';
 
 export const anchor: AutolinkParser.AnchorParser = lazy(() => validate('>>', fmap(focus(
   /^>>(?:[A-Za-z][0-9A-Za-z]*(?:-[0-9A-Za-z]+)*\/)?[0-9A-Za-z]+(?:-[0-9A-Za-z]+)*(?![0-9A-Za-z@#:])/,
-  context({ syntax: { inline: {
-    link: true,
-    autolink: false,
-  }}},
   convert(
     source =>
       `[${source}]{ ${
@@ -25,5 +21,5 @@ export const anchor: AutolinkParser.AnchorParser = lazy(() => validate('>>', fma
         ? `/@${source.slice(2).replace('/', '/timeline/')}`
         : `?at=${source.slice(2)}`
       } }`,
-    union([link])))),
+    union([textlink]))),
   ([el]) => [define(el, { class: 'anchor' })])));

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

@@ -1,17 +1,13 @@
 import { AutolinkParser } from '../../inline';
-import { union, rewrite, context, open, convert, fmap, lazy } from '../../../combinator';
-import { link } from '../link';
+import { union, rewrite, open, convert, fmap, lazy } from '../../../combinator';
+import { textlink } from '../link';
 import { emoji } from './hashtag';
 import { str } from '../../source';
 import { define } from 'typed-dom/dom';
 
 export const hashnum: AutolinkParser.HashnumParser = lazy(() => fmap(rewrite(
   open('#', str(new RegExp(/^[0-9]{1,16}(?![^\p{C}\p{S}\p{P}\s]|emoji|['_])/u.source.replace(/emoji/, emoji), 'u'))),
-  context({ syntax: { inline: {
-    link: true,
-    autolink: false,
-  }}},
   convert(
     source => `[${source}]{ ${source.slice(1)} }`,
-    union([link])))),
+    union([textlink]))),
   ([el]) => [define(el, { class: 'hashnum', href: null })]));

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

@@ -1,6 +1,6 @@
 import { AutolinkParser } from '../../inline';
-import { union, tails, verify, rewrite, context, open, convert, fmap, lazy } from '../../../combinator';
-import { link } from '../link';
+import { union, tails, verify, rewrite, open, convert, fmap, lazy } from '../../../combinator';
+import { textlink } from '../link';
 import { str } from '../../source';
 import { define } from 'typed-dom/dom';
 
@@ -24,10 +24,6 @@ export const hashtag: AutolinkParser.HashtagParser = lazy(() => fmap(rewrite(
         ].join('').replace(/emoji/g, emoji), 'u')),
         ([source]) => source.length <= 128),
     ])),
-  context({ syntax: { inline: {
-    link: true,
-    autolink: false,
-  }}},
   convert(
     source =>
       `[${source}]{ ${
@@ -35,5 +31,5 @@ export const hashtag: AutolinkParser.HashtagParser = lazy(() => fmap(rewrite(
         ? `https://${source.slice(1).replace('/', '/hashtags/')}`
         : `/hashtags/${source.slice(1)}`
       } }`,
-    union([link])))),
+    union([textlink]))),
   ([el]) => [define(el, { class: 'hashtag' }, el.innerText)]));

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

@@ -72,6 +72,7 @@ describe('Unit: parser/inline/autolink/url', () => {
       assert.deepStrictEqual(inspect(parser('http://host>')), [['<a href="http://host" target="_blank">http://host</a>'], '>']);
       assert.deepStrictEqual(inspect(parser('http://host（')), [['<a href="http://host" target="_blank">http://host</a>'], '（']);
       assert.deepStrictEqual(inspect(parser('http://host）')), [['<a href="http://host" target="_blank">http://host</a>'], '）']);
+      assert.deepStrictEqual(inspect(parser('http://host\\"')), [['<a href="http://host" target="_blank">http://host</a>'], '\\"']);
       assert.deepStrictEqual(inspect(parser('http://host!?**.*--++==~~^^')), [['<a href="http://host" target="_blank">http://host</a>'], '!?**.*--++==~~^^']);
     });
 

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

@@ -1,22 +1,21 @@
 import { AutolinkParser } from '../../inline';
-import { union, some, validate, focus, rewrite, context, creator, convert, surround, open, lazy } from '../../../combinator';
-import { link } from '../link';
+import { union, some, validate, focus, rewrite, precedence, creator, convert, surround, open, lazy } from '../../../combinator';
+import { textlink } from '../link';
 import { unescsource } from '../../source';
 
-const closer = /^[-+*=~^,.;:!?]*(?=["`|\[\](){}<>]|\\?$)/;
+const closer = /^[-+*=~^,.;:!?]*(?=[\\"`|\[\](){}<>]|$)/;
 
 export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'https://'], rewrite(
   open(
     /^https?:\/\/(?=[\x21-\x7E])/,
     focus(/^[\x21-\x7E]+/, some(union([bracket, some(unescsource, closer)])))),
-  context({ syntax: { inline: { link: true } } },
   convert(
     url => `{ ${url} }`,
-    union([link]))))));
+    union([textlink])))));
 
-const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(union([
+const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(precedence(3, union([
   surround('(', some(union([bracket, unescsource]), ')'), ')', true),
   surround('[', some(union([bracket, unescsource]), ']'), ']', true),
   surround('{', some(union([bracket, unescsource]), '}'), '}', true),
-  surround('"', some(unescsource, '"'), '"', true),
-])));
+  surround('"', precedence(8, some(unescsource, '"')), '"', true),
+]))));

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';
@@ -8,23 +8,23 @@ import { unshift, push } from 'spica/array';
 
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
-export const bracket: BracketParser = lazy(() => creator(union([
-  surround(str('('), str(index), str(')')),
-  surround(str('('), some(inline, ')'), str(')'), true,
+export const bracket: BracketParser = lazy(() => creator(0, union([
+  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('[#', ']', '\n', 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('[#', ']', '\n', f
   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('[#', ']', '\n', f
         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

@@ -21,13 +21,13 @@ describe('Unit: parser/inline/extension/placeholder', () => {
       assert.deepStrictEqual(inspect(parser('[^\na]')), undefined);
       assert.deepStrictEqual(inspect(parser('[^\\\na]')), undefined);
       assert.deepStrictEqual(inspect(parser('[^ !http://host]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a')), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a\n]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a\n\n]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a\\\n]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a\\\n\\\n]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a\nb]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a\\\nb]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[^a')), [['[^', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\n]')), [['[^', 'a'], '\n]']);
+      assert.deepStrictEqual(inspect(parser('[^a\n\n]')), [['[^', 'a'], '\n\n]']);
+      assert.deepStrictEqual(inspect(parser('[^a\\\n]')), [['[^', 'a'], '\\\n]']);
+      assert.deepStrictEqual(inspect(parser('[^a\\\n\\\n]')), [['[^', 'a'], '\\\n\\\n]']);
+      assert.deepStrictEqual(inspect(parser('[^a\nb]')), [['[^', 'a'], '\nb]']);
+      assert.deepStrictEqual(inspect(parser('[^a\\\nb]')), [['[^', 'a'], '\\\nb]']);
       assert.deepStrictEqual(inspect(parser('[[]')), undefined);
       assert.deepStrictEqual(inspect(parser('[]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[]]')), undefined);
@@ -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(['[:', '[^'], ']', '\n', surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], creator(precedence(3, surround(
   str(/^\[[:^]/),
-  startTight(some(union([inline]), ']')),
+  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>'], '']);