securemark 0.255.0 → 0.257.0

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>'], '']);

package/src/parser/inline/math.ts

@@ -1,19 +1,18 @@
 import { MathParser } from '../inline';
-import { union, some, validate, focus, rewrite, creator, surround, lazy } from '../../combinator';
+import { union, some, validate, rewrite, precedence, creator, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { html } from 'typed-dom/dom';
 
-const syntax = /^(?:[ "([](?!\$)|\\{(?!\$)|\\[\\}$]?|^`|`(?!`)|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/;
+const syntax = /^(?:[ ([](?!\$)|\\[\\{}$]?|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/;
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
-export const math: MathParser = lazy(() => creator(validate('$', rewrite(
+export const math: MathParser = lazy(() => validate('$', creator(precedence(7, rewrite(
   union([
     surround('$', bracket, '$'),
     surround(
       /^\$(?![\s{}])/,
       some(union([
         bracket,
-        quote,
         str(syntax),
       ])),
       /^\$(?![0-9A-Za-z])/),
@@ -31,7 +30,7 @@ export const math: MathParser = lazy(() => creator(validate('$', rewrite(
             'data-invalid-message': `"${source.match(forbiddenCommand)![0]}" command is forbidden`,
           },
       source)
-  ], '']))));
+  ], ''])))));
 
 const bracket: MathParser.BracketParser = lazy(() => creator(surround(
   '{',
@@ -41,13 +40,3 @@ const bracket: MathParser.BracketParser = lazy(() => creator(surround(
   ])),
   '}',
   true)));
-
-const quote: MathParser.QuoteParser = lazy(() => creator(surround(
-  '``',
-  some(union([
-    quote,
-    bracket,
-    focus(/^(?:\\[\\{}$]|`(?!`)|[^`{}"$\n\P{ASCII}])*/u, str(syntax)),
-  ])),
-  /^"?/,
-  true)));

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

@@ -45,8 +45,6 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![[]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]]{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\nb]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a\\\nb]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{ttp://host}')), [['<img class="media invalid" data-src="ttp://host" alt="">'], '']);

package/src/parser/inline/media.ts

@@ -1,6 +1,6 @@
 import { undefined, location } from 'spica/global';
 import { MediaParser } from '../inline';
-import { union, inits, tails, some, validate, verify, guard, creator, surround, open, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, validate, verify, guard, precedence, creator, surround, open, dup, lazy, fmap, bind } from '../../combinator';
 import { link, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
@@ -17,13 +17,13 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'], '}', '\n', bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10, precedence(3, bind(verify(fmap(open(
   '!',
   guard(context => context.syntax?.inline?.media ?? true,
   tails([
     dup(surround(
-      /^\[(?!\s*\\\s)/,
-      some(union([unsafehtmlentity, bracket, txt]), ']', /^\\?\n/),
+      '[',
+      some(union([unsafehtmlentity, bracket, txt]), ']', [[/^\\?\n/, 9]]),
       ']',
       true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
@@ -57,13 +57,13 @@ export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'],
       link as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
-  }))));
+  })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('"'), some(union([unsafehtmlentity, txt]), '"'), str('"'), true),
+  surround(str('"'), precedence(8, some(union([unsafehtmlentity, txt]), '"')), str('"'), true),
 ]));
 
 const option: MediaParser.ParameterParser.OptionParser = union([

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

@@ -17,11 +17,11 @@ describe('Unit: parser/inline/reference', () => {
       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);
@@ -57,7 +57,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[^a,]]')), [['<sup class="reference" data-abbr="a,"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a, ]]')), [['<sup class="reference" data-abbr="a,"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a ]]')), [['<sup class="reference" data-abbr="a"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a  ]]')), [['<sup class="invalid"><span>^a  </span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a  ]]')), [['<sup class="invalid"><span>^a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a b]]')), [['<sup class="reference" data-abbr="a b"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a  b]]')), [['<sup class="invalid"><span>^a  b</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a|]]')), [['<sup class="reference" data-abbr="a"><span></span></sup>'], '']);
@@ -75,7 +75,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[^a|  ]]')), [['<sup class="reference" data-abbr="a"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1]]')), [['<sup class="invalid"><span>^1</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1a]]')), [['<sup class="reference" data-abbr="1a"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1 ]]')), [['<sup class="invalid"><span>^1 </span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^1 ]]')), [['<sup class="invalid"><span>^1</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1 a]]')), [['<sup class="reference" data-abbr="1 a"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1|]]')), [['<sup class="invalid"><span>^1|</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1 |]]')), [['<sup class="invalid"><span>^1 |</span></sup>'], '']);
@@ -86,11 +86,11 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser(`[[^A's, Aces']]`)), [[`<sup class="reference" data-abbr="A's, Aces'"><span></span></sup>`], '']);
       assert.deepStrictEqual(inspect(parser('[[^^]]')), [['<sup class="invalid"><span>^^</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[\\^]]')), [['<sup class="reference"><span>^</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ ]]')), [['<sup class="invalid"><span>^ </span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ ]]')), [['<sup class="invalid"><span>^</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^ a]]')), [['<sup class="invalid"><span>^ a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^ |]]')), [['<sup class="invalid"><span>^ |</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^ |b]]')), [['<sup class="invalid"><span>^ |b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ | ]]')), [['<sup class="invalid"><span>^ | </span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ | ]]')), [['<sup class="invalid"><span>^ |</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^ | b]]')), [['<sup class="invalid"><span>^ | b</span></sup>'], '']);
     });
 

package/src/parser/inline/reference.ts

@@ -1,12 +1,13 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, validate, guard, context, creator, surround, open, lazy, fmap, bind } from '../../combinator';
+import { Result } from '../../combinator/data/parser';
+import { union, subsequence, some, validate, guard, context, precedence, creator, recursion, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { str, stropt } from '../source';
-import { regBlankStart, trimBlank, stringify } from '../util';
+import { regBlankStart, trimBlankStart, trimNodeEnd, stringify } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]', '\n', fmap(surround(
+export const reference: ReferenceParser = lazy(() => validate('[[', creator(recursion(precedence(6, surround(
   '[[',
   guard(context => context.syntax?.inline?.reference ?? true,
   context({ syntax: { inline: {
@@ -21,11 +22,13 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
   }}, delimiters: undefined },
   subsequence([
     abbr,
-    open(stropt(/^(?=\^)/), some(inline, ']', /^\\?\n/)),
-    trimBlank(some(inline, ']', /^\\?\n/)),
+    open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 3], [']]', 6]])),
+    trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 3], [']]', 6]])),
   ]))),
-  ']]'),
-  ns => [html('sup', attributes(ns), [html('span', defrag(ns))])]))));
+  ']]',
+  false,
+  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest)))))));
 
 const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
   '^',
@@ -48,3 +51,12 @@ function attributes(ns: (string | HTMLElement)[]): Record<string, string | undef
         }
       : { class: 'reference' };
 }
+
+export function optimize(opener: string, ns: readonly (string | HTMLElement)[], rest: string): Result<string> {
+  let count = 0;
+  for (let i = 0; i < ns.length - 1; i += 2) {
+    if (ns[i] !== '' || ns[i + 1] !== opener[0]) break;
+    ++count;
+  }
+  return [[opener[0].repeat(opener.length + count)], rest.slice(count)];
+}

package/src/parser/inline/ruby.ts

@@ -1,47 +1,49 @@
 import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, validate, verify, focus, creator, surround, lazy, bind } from '../../combinator';
+import { sequence, validate, verify, focus, creator, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
 import { isStartTightNodes } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
-export const ruby: RubyParser = lazy(() => creator(validate('[', ')', '\n', bind(verify(
+export const ruby: RubyParser = lazy(() => validate('[', creator(fmap(verify(
   sequence([
-    surround('[', focus(/^(?:\\[^\n]|[^\\\[\]\n])+(?=]\()/, text), ']'),
-    surround('(', focus(/^(?:\\[^\n]|[^\\\(\)\n])+(?=\))/, text), ')'),
+    surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
+    surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),
   ]),
   ([texts]) => isStartTightNodes(texts)),
-  ([texts, rubies], rest) => {
-    const tail = typeof texts[texts.length - 1] === 'object'
-      ? [texts.pop()!]
-      : [];
-    tail.length === 0 && texts[texts.length - 1] === '' && texts.pop();
+  ([texts, rubies]) => {
+    texts[texts.length - 1] === '' && texts.pop();
     switch (true) {
       case rubies.length <= texts.length:
-        return [[html('ruby', attributes(texts, rubies), defrag(push(texts
-          .reduce((acc, _, i) =>
-            push(acc, unshift([texts[i]],
-              i < rubies.length && rubies[i]
-                ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
-                : [html('rt')]))
-          , []), tail)))], rest];
+        return [
+          html('ruby', attributes(texts, rubies), defrag(texts
+            .reduce((acc, _, i) =>
+              push(acc, unshift([texts[i]],
+                i < rubies.length && rubies[i]
+                  ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
+                  : [html('rt')]))
+            , []))),
+        ];
       case texts.length === 1 && [...texts[0]].length >= rubies.length:
-        return [[html('ruby', attributes(texts, rubies), defrag(push([...texts[0]]
-          .reduce((acc, _, i, texts) =>
-            push(acc, unshift([texts[i]],
-              i < rubies.length && rubies[i]
-                ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
-                : [html('rt')]))
-          , []), tail)))], rest];
+        return [
+          html('ruby', attributes(texts, rubies), defrag([...texts[0]]
+            .reduce((acc, _, i, texts) =>
+              push(acc, unshift([texts[i]],
+                i < rubies.length && rubies[i]
+                  ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
+                  : [html('rt')]))
+            , []))),
+        ];
       default:
         assert(rubies.length > 0);
-        return [[html('ruby', attributes(texts, rubies), defrag(push(unshift(
-          [texts.join(' ')],
-          [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]), tail)))
-        ], rest];
+        return [
+          html('ruby', attributes(texts, rubies), defrag(unshift(
+            [texts.join(' ')],
+            [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]))),
+        ];
     }
   }))));
 

package/src/parser/inline/strong.ts

@@ -1,5 +1,5 @@
 import { StrongParser } 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 { str } from '../source';
@@ -7,7 +7,7 @@ import { startTight, blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const strong: StrongParser = lazy(() => creator(surround(
+export const strong: StrongParser = lazy(() => creator(precedence(1, surround(
   str('**'),
   startTight(some(union([
     some(inline, blankWith('**')),
@@ -18,4 +18,4 @@ export const strong: StrongParser = lazy(() => creator(surround(
   ])), '*'),
   str('**'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

package/src/parser/inline/template.ts

@@ -1,17 +1,17 @@
 import { undefined } from 'spica/global';
 import { TemplateParser } from '../inline';
-import { union, some, rewrite, creator, surround, lazy } from '../../combinator';
+import { union, some, rewrite, precedence, creator, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const template: TemplateParser = lazy(() => creator(rewrite(
+export const template: TemplateParser = lazy(() => creator(precedence(3, rewrite(
   surround('{{', some(union([bracket, escsource]), '}'), '}}', true),
-  source => [[html('span', { class: 'template' }, source.replace(/\x1B/g, ''))], ''])));
+  source => [[html('span', { class: 'template' }, source.replace(/\x1B/g, ''))], '']))));
 
 const bracket: TemplateParser.BracketParser = lazy(() => union([
   surround(str('('), some(union([bracket, escsource]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('"'), some(escsource, /^"|^\\?\n/), str('"'), true),
+  surround(str('"'), precedence(8, some(escsource, /^"|^\\?\n/)), str('"'), true),
 ]));

package/src/parser/inline.test.ts

@@ -142,27 +142,30 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('${{{a}}}')), [['$', '<span class="template">{{{a}}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney Micro$oft')), [['Di', '$', 'ney', ' ', 'Micro', '$', 'oft'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney, Micro$oft')), [['Di', '$', 'ney', ',', ' ', 'Micro', '$', 'oft'], '']);
-      assert.deepStrictEqual(inspect(parser('(((a))')), [['(', '<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((((a))')), [['(', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('(((a))')), [['', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((((a))')), [['((', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['', '[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[$-1]]]')), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><span><a href="a">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></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('[~a@b')), [['[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[~http://host')), [['', '[', '~', '<a href="http://host" target="_blank">http://host</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[~a@b')), [['', '[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[~~a~~]')), [['[', '<del>a</del>', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[^http://host')), [['[', '^', '<a href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a@b')), [['[', '^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^http://host')), [['[^', '<a href="http://host" target="_blank">http://host</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>', '<em>b<br>c</em>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a href="/">/</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[[', '<em>a<br>b</em>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });
@@ -228,7 +231,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a*#b')), [['<em>a</em>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation"><span>a</span></sup>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a]]#b')), [['<sup class="reference"><span>a</span></sup>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a')), [['', '[', '<a href="/hashtags/a" class="hashtag">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('|#a')), [['|', '<a href="/hashtags/a" class="hashtag">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' #a')), [[' ', '<a href="/hashtags/a" class="hashtag">#a</a>'], '']);
     });

package/src/parser/util.ts

@@ -5,9 +5,25 @@ import { union, some, verify, convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
 import { linebreak, unescsource } from './source';
 import { invisibleHTMLEntityNames } from './api/normalize';
-import { reduce } from 'spica/memoize';
+import { memoize, reduce } from 'spica/memoize';
 import { push } from 'spica/array';
 
+export function clean<P extends Parser<unknown>>(parser: P): P;
+export function clean<T>(parser: Parser<T, MarkdownParser.Context>): Parser<T, MarkdownParser.Context> {
+  const clean = memoize<MarkdownParser.Context, MarkdownParser.Context>(context => ({
+    resources: context.resources,
+    precedence: context.precedence,
+    delimiters: context.delimiters,
+    host: context.host,
+    url: context.url,
+    id: context.id,
+    header: context.header,
+    cache: context.caches,
+  }), new WeakMap());
+  return (source, context) =>
+    parser(source, context.syntax ? clean(context) : context);
+}
+
 export const regBlankStart = new RegExp(
   /^(?:\\?[^\S\n]|&IHN;|<wbr>)+/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
 
@@ -183,7 +199,7 @@ export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>):
 //  }
 //  return nodes;
 //}
-function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
+export function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
   const skip = nodes.length > 0 &&
     typeof nodes[nodes.length - 1] === 'object' &&
     nodes[nodes.length - 1]['className'] === 'indexer'