securemark 0.256.0 → 0.257.2

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 { LinkParser, TextLinkParser } from '../inline';
+import { Result, eval } from '../../combinator/data/parser';
+import { union, inits, tails, subsequence, 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 { trimBlankStart, trimNodeEnd, stringify } from '../util';
+import { unescsource, str } from '../source';
+import { trimNode, stringify } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 
@@ -15,9 +15,9 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], bind(
+export const link: LinkParser = lazy(() => validate(['[', '{'], creator(10, precedence(2, bind(
   guard(context => context.syntax?.inline?.link ?? true,
-  reverse(tails([
+  fmap(subsequence([
     context({ syntax: { inline: {
       link: false,
     }}},
@@ -36,15 +36,22 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], bind
           media: false,
           autolink: false,
         }}},
-        trimBlankStart(some(inline, ']', /^\\?\n/))),
+        some(inline, ']', [[/^\\?\n/, 9], [']', 2]])),
         ']',
-        true),
+        true,
+        undefined,
+        ([, ns = [], rest], next) => next[0] === ']' ? undefined : optimize('[', ns, rest)),
     ]))),
+    // 全体の失敗が確定した時も解析し予算を浪費している
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ]))),
-  ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
+  ]),
+  ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []])),
+  ([content, params]: [(HTMLElement | string)[], string[]], rest, context) => {
+    if (params.length === 0) return;
+    assert(content[0] !== '' || params.length === 0);
+    if (content[0] === '') return [content, rest];
     assert(params.every(p => typeof p === 'string'));
-    content = trimNodeEnd(content);
+    if (content.length !== 0 && trimNode(content).length === 0) return;
     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()!;
@@ -60,12 +67,37 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], bind
     if (el.classList.contains('invalid')) return [[el], rest];
     assert(el.classList.length === 0);
     return [[define(el, attributes('link', [], optspec, params))], rest];
-  }))));
+  })))));
 
-export const uri: LinkParser.ParameterParser.UriParser = union([
+export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], creator(10, precedence(2, bind(
+  reverse(tails([
+    dup(surround('[', some(union([unescsource]), ']'), ']')),
+    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+  ])),
+  ([params, content = []], rest, context) => {
+    assert(params[0] === '\r');
+    params.shift();
+    assert(params.every(p => typeof p === 'string'));
+    trimNode(content);
+    const INSECURE_URI = params.shift()!;
+    assert(INSECURE_URI === INSECURE_URI.trim());
+    assert(!INSECURE_URI.match(/\s/));
+    const el = elem(
+      INSECURE_URI,
+      defrag(content),
+      new ReadonlyURL(
+        resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
+        context.host?.href || location.href),
+      context.host?.origin || location.origin);
+    assert(!el.classList.contains('invalid'));
+    assert(el.classList.length === 0);
+    return [[define(el, attributes('link', [], optspec, params))], rest];
+  })))));
+
+export const uri: LinkParser.ParameterParser.UriParser = fmap(union([
   open(/^[^\S\n]+/, str(/^\S+/)),
   str(/^[^\s{}]+/),
-]);
+]), ([uri]) => ['\r', uri]);
 
 export const option: LinkParser.ParameterParser.OptionParser = union([
   fmap(str(/^[^\S\n]+nofollow(?=[^\S\n]|})/), () => [` rel="nofollow"`]),
@@ -90,8 +122,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;
   }
 }
 
@@ -163,3 +195,12 @@ function decode(uri: string): string {
     return uri.replace(/\s+/g, encodeURI);
   }
 }
+
+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/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(1, 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,21 +1,19 @@
 import { MathParser } from '../inline';
-import { union, some, validate, focus, rewrite, creator, surround, lazy } from '../../combinator';
-import { escsource, str } from '../source';
+import { union, some, validate, focus, rewrite, precedence, creator, surround, lazy } from '../../combinator';
+import { escsource, unescsource } from '../source';
 import { html } from 'typed-dom/dom';
 
-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(rewrite(
   union([
-    surround('$', bracket, '$'),
+    surround('$', precedence(6, bracket), '$'),
     surround(
       /^\$(?![\s{}])/,
-      some(union([
+      precedence(3, some(union([
         bracket,
-        quote,
-        str(syntax),
-      ])),
+        focus(/^(?:[ ([](?!\$)|\\[\\{}$]?|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/, some(unescsource)),
+      ]))),
       /^\$(?![0-9A-Za-z])/),
   ]),
   (source, { caches: { math: cache } = {} }) => [[
@@ -41,13 +39,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,13 +1,13 @@
 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 { link, uri, option as linkoption, resolve } from './link';
+import { union, inits, tails, some, validate, verify, guard, precedence, creator, surround, open, dup, lazy, fmap, bind } from '../../combinator';
+import { textlink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, push } from 'spica/array';
+import { unshift, shift, push } from 'spica/array';
 
 const optspec = {
   'width': [],
@@ -17,18 +17,18 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'], bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10, precedence(2, 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]*}/)),
   ]))),
-  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], bs] : [[''], as]),
+  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], shift(bs)[1]] : [[''], shift(as)[1]]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
     assert(text === text.trim());
@@ -54,16 +54,16 @@ export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'],
     }
     if (context.syntax?.inline?.link === false || cache && cache.tagName !== 'IMG') return [[el], rest];
     return fmap(
-      link as MediaParser,
+      textlink 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

@@ -14,14 +14,15 @@ describe('Unit: parser/inline/reference', () => {
       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);

package/src/parser/inline/reference.ts

@@ -1,14 +1,16 @@
 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 { union, subsequence, some, validate, guard, context, precedence, creator, recursion, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
+import { optimize } from './link';
 import { str, stropt } from '../source';
-import { regBlankStart, trimBlankStart, trimNodeEnd, stringify } from '../util';
+import { regBlankStart, startLoose, trimNode, stringify } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => creator(validate('[[', fmap(surround(
+export const reference: ReferenceParser = lazy(() => validate('[[', creator(recursion(precedence(6, surround(
   '[[',
   guard(context => context.syntax?.inline?.reference ?? true,
+  startLoose(
   context({ syntax: { inline: {
     annotation: false,
     reference: false,
@@ -21,11 +23,13 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', fmap
   }}, delimiters: undefined },
   subsequence([
     abbr,
-    open(stropt(/^(?=\^)/), some(inline, ']', /^\\?\n/)),
-    trimBlankStart(some(inline, ']', /^\\?\n/)),
-  ]))),
-  ']]'),
-  ns => [html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])]))));
+    open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
+    some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]]),
+  ])), ']')),
+  ']]',
+  false,
+  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNode(defrag(ns)))])], rest],
+  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest)))))));
 
 const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
   '^',

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('[', 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(2, 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,32 @@ 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('((${))}$')), [['', '((', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
       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('[[${]]}$')), [['', '[[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       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('[#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 +233,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/inline.ts

@@ -34,6 +34,7 @@ export import MathParser = InlineParser.MathParser;
 export import ExtensionParser = InlineParser.ExtensionParser;
 export import RubyParser = InlineParser.RubyParser;
 export import LinkParser = InlineParser.LinkParser;
+export import TextLinkParser = InlineParser.TextLinkParser;
 export import HTMLParser = InlineParser.HTMLParser;
 export import InsertionParser = InlineParser.InsertionParser;
 export import DeletionParser = InlineParser.DeletionParser;