securemark 0.255.1 → 0.257.1

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 { 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 { trimBlank, 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(['[', '{'], '}', '\n', bind(
+export const link: LinkParser = lazy(() => validate(['[', '{'], creator(10, precedence(3, bind(
   guard(context => context.syntax?.inline?.link ?? true,
-  reverse(tails([
+  fmap(subsequence([
     context({ syntax: { inline: {
       link: false,
     }}},
@@ -36,14 +36,22 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
           media: false,
           autolink: false,
         }}},
-        trimBlank(some(inline, ']', /^\\?\n/))),
+        some(inline, ']', [[/^\\?\n/, 9], [']', 3]])),
         ']',
-        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'));
+    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()!;
@@ -59,12 +67,37 @@ 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([
+export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], creator(10, precedence(3, 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"`]),
@@ -89,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;
   }
 }
 
@@ -162,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(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,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(['![', '!{'], '}', '\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]*}/)),
   ]))),
-  ([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);
@@ -57,7 +58,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 +76,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 +87,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,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, trimBlank, stringify } from '../util';
+import { regBlankStart, startLoose, trimNode, 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,
+  startLoose(
   context({ syntax: { inline: {
     annotation: false,
     reference: false,
@@ -21,11 +23,13 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
   }}, delimiters: undefined },
   subsequence([
     abbr,
-    open(stropt(/^(?=\^)/), some(inline, ']', /^\\?\n/)),
-    trimBlank(some(inline, ']', /^\\?\n/)),
-  ]))),
-  ']]'),
-  ns => [html('sup', attributes(ns), [html('span', defrag(ns))])]))));
+    open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 3], [']]', 6]])),
+    some(inline, ']', [[/^\\?\n/, 9], [']', 3], [']]', 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('[', ')', '\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]))));