securemark 0.255.0 → 0.257.0

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

@@ -17,11 +17,11 @@ describe('Unit: parser/inline/annotation', () => {
       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 +42,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,11 +1,12 @@
 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 './reference';
+import { trimBlankStart, trimNodeEnd } 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,
   context({ syntax: { inline: {
@@ -19,6 +20,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))])]))));
+  trimBlankStart(some(union([inline]), ')', [[/^\\?\n/, 9], [')', 3], ['))', 6]])))),
+  '))',
+  false,
+  ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest)))))));

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

@@ -1,7 +1,8 @@
 import { AutolinkParser } from '../../inline';
-import { union, some, validate, focus, rewrite, context, creator, convert, surround, open, lazy } from '../../../combinator';
+import { union, some, validate, focus, rewrite, precedence, creator, convert, surround, open, lazy } from '../../../combinator';
 import { link } from '../link';
 import { unescsource } from '../../source';
+import { clean } from '../../util';
 
 const closer = /^[-+*=~^,.;:!?]*(?=["`|\[\](){}<>]|\\?$)/;
 
@@ -9,14 +10,13 @@ export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'ht
   open(
     /^https?:\/\/(?=[\x21-\x7E])/,
     focus(/^[\x21-\x7E]+/, some(union([bracket, some(unescsource, closer)])))),
-  context({ syntax: { inline: { link: true } } },
   convert(
     url => `{ ${url} }`,
-    union([link]))))));
+    clean(union([link]))))));
 
-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>'], '']);

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,12 +1,12 @@
 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';
 import { str } from '../source';
-import { trimBlank, stringify } from '../util';
+import { trimBlankStart, trimNodeEnd, stringify } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 
@@ -15,7 +15,7 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}', '\n', 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(['[', '{'], '}',
           media: false,
           autolink: false,
         }}},
-        trimBlank(some(inline, ']', /^\\?\n/))),
+        trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 3]]))),
         ']',
         true),
     ]))),
@@ -44,6 +44,7 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
   ]))),
   ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
     assert(params.every(p => typeof p === 'string'));
+    content = trimNodeEnd(content);
     if (eval(some(autolink)(stringify(content), context))?.some(node => typeof node === 'object')) return;
     assert(!html('div', content).querySelector('a, .media, .annotation, .reference') || (content[0] as HTMLElement).matches('.media'));
     const INSECURE_URI = params.shift()!;
@@ -59,7 +60,7 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
     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+/)),
@@ -89,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;
   }
 }