securemark 0.257.0 → 0.257.3

package/markdown.d.ts

@@ -1,22 +1,6 @@
 import { Parser, Ctx } from './src/combinator/data/parser';
 import { Dict } from 'spica/dict';
 
-/*
-
-Operator precedence
-
-9: \n, \\\n
-8: `, "
-7: $
-6: (()), [[]]
-5: <tag></tag>
-4: [% %]
-3: (), [], {}
-2: ==, ++, ~~
-1: *, **
-
-*/
-
 declare abstract class Markdown<T> {
   private parser?: T;
 }
@@ -869,11 +853,20 @@ export namespace MarkdownParser {
       // { uri }
       // [abc]{uri nofollow}
       Inline<'link'>,
-      Parser<HTMLAnchorElement, Context, [
+      Parser<HTMLElement | string, Context, [
         LinkParser.ContentParser,
         LinkParser.ParameterParser,
       ]> {
     }
+    export interface TextLinkParser extends
+      // { uri }
+      // [abc]{uri nofollow}
+      Inline<'textlink'>,
+      Parser<HTMLAnchorElement, Context, [
+        LinkParser.TextParser,
+        LinkParser.ParameterParser,
+      ]> {
+    }
     export namespace LinkParser {
       export interface ContentParser extends
         Inline<'link/content'>,
@@ -883,6 +876,12 @@ export namespace MarkdownParser {
           InlineParser,
         ]> {
       }
+      export interface TextParser extends
+        Inline<'link/text'>,
+        Parser<string[], Context, [
+          SourceParser.UnescapableSourceParser,
+        ]> {
+      }
       export interface ParameterParser extends
         Inline<'link/parameter'>,
         Parser<string[], Context, [
@@ -1107,7 +1106,7 @@ export namespace MarkdownParser {
         // https://host
         Inline<'url'>,
         Parser<HTMLAnchorElement, Context, [
-          LinkParser,
+          TextLinkParser,
         ]> {
       }
       export namespace UrlParser {
@@ -1149,28 +1148,28 @@ export namespace MarkdownParser {
         // @user
         Inline<'account'>,
         Parser<HTMLAnchorElement, Context, [
-          LinkParser,
+          TextLinkParser,
         ]> {
       }
       export interface HashtagParser extends
         // #tag
         Inline<'hashtag'>,
         Parser<HTMLAnchorElement, Context, [
-          LinkParser,
+          TextLinkParser,
         ]> {
       }
       export interface HashnumParser extends
         // #1
         Inline<'hashnum'>,
         Parser<HTMLAnchorElement, Context, [
-          LinkParser,
+          TextLinkParser,
         ]> {
       }
       export interface AnchorParser extends
         // >>1
         Inline<'anchor'>,
         Parser<HTMLAnchorElement, Context, [
-          LinkParser,
+          TextLinkParser,
         ]> {
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.257.0",
+  "version": "0.257.3",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/combinator/data/parser/inits.ts

@@ -11,10 +11,10 @@ export function inits<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
     let nodes: T[] | undefined;
     for (let i = 0, len = parsers.length; i < len; ++i) {
       if (rest === '') break;
+      if (context.delimiters?.match(rest, context.precedence)) break;
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) break;
-      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);

package/src/combinator/data/parser/sequence.ts

@@ -11,10 +11,10 @@ export function sequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D
     let nodes: T[] | undefined;
     for (let i = 0, len = parsers.length; i < len; ++i) {
       if (rest === '') return;
+      if (context.delimiters?.match(rest, context.precedence)) break;
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) return;
-      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);

package/src/debug.test.ts

@@ -5,7 +5,7 @@ import { querySelector, querySelectorAll } from 'typed-dom/query';
 export function inspect(result: Result<HTMLElement | string>, until: number | string = Infinity): Result<string> {
   return result && [
     eval(result).map((node, i, nodes) => {
-      assert(node || node === '' && '([{'.includes(nodes[i + 1] as string));
+      assert(node || node === '' && '([{'.includes(nodes[i + 1][0]));
       if (typeof node === 'string') return node;
       node = node.cloneNode(true);
       assert(!querySelector(node, '.invalid[data-invalid-message$="."]'));

package/src/parser/block/table.test.ts

@@ -29,6 +29,11 @@ describe('Unit: parser/block/table', () => {
       assert.deepStrictEqual(inspect(parser('|\n|-\n|')), [['<table><thead><tr></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('||\n|-|\n||')), [['<table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|||\n|-|-|\n|||')), [['<table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|"|\n|-\n|')), [['<table><thead><tr><th>"</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|`|\n|-\n|')), [['<table><thead><tr><th>`</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|`|`|\n|-\n|')), [['<table><thead><tr><th><code data-src="`|`">|</code></th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|((|\n|-\n|')), [['<table><thead><tr><th>((</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
+      assert.deepStrictEqual(inspect(parser('|${|\n|-\n|')), [['<table><thead><tr><th>${</th></tr></thead><tbody><tr></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|b|\n|-|-|\n|1|2|')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|b\n|-|-\n|1|2')), [['<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'], '']);
       assert.deepStrictEqual(inspect(parser('|a|\n|-|\n|1|')), [['<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'], '']);

package/src/parser/block/table.ts

@@ -2,6 +2,7 @@ import { TableParser } from '../block';
 import { union, sequence, some, block, line, validate, focus, rewrite, creator, surround, open, fallback, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { contentline } from '../source';
+import { trimNode } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { push } from 'spica/array';
 
@@ -24,7 +25,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
   ])));
 
 const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creator(fallback(fmap(
-  line(surround(/^(?=\|)/, some(union([parser])), /^\|?\s*$/, optional)),
+  line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
   es => [html('tr', es)]),
   rewrite(contentline, source => [[
     html('tr', {
@@ -46,17 +47,17 @@ const align: AlignParser = creator(fmap(open(
   ns => [html('td', defrag(ns))]));
 
 const cell: CellParser = surround(
-  /^\|(?:\\?\s)*(?=\S)/,
-  some(union([inline]), /^(?:\\?\s)*(?=\||\\?$)/),
+  /^\|\s*(?=\S)/,
+  some(union([inline]), /^\|/, [[/^[|\\]?\s*$/, 9]]),
   /^[^|]*/, true);
 
 const head: CellParser.HeadParser = creator(fmap(
   cell,
-  ns => [html('th', defrag(ns))]));
+  ns => [html('th', trimNode(defrag(ns)))]));
 
 const data: CellParser.DataParser = creator(fmap(
   cell,
-  ns => [html('td', defrag(ns))]));
+  ns => [html('td', trimNode(defrag(ns)))]));
 
 function format(rows: HTMLTableRowElement[]): HTMLTableRowElement[] {
   const aligns = rows[0].classList.contains('invalid')

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

@@ -14,14 +14,15 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('(())')), undefined);
       assert.deepStrictEqual(inspect(parser('(()))')), undefined);
       assert.deepStrictEqual(inspect(parser('(( ))')), undefined);
+      assert.deepStrictEqual(inspect(parser('(( (a')), [['', '(('], ' (a']);
       assert.deepStrictEqual(inspect(parser('((\n))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\na))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\\na))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\n))')), [['(('], '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('((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/annotation.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -39,6 +39,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(ABBR, ABBR)')), [['(', 'ABBR, ABBR', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(\\a)')), [['<span class="paren">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(==)')), [['<span class="paren">(==)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('($)$')), [['', '(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(')')), undefined);
       assert.deepStrictEqual(inspect(parser('（１，２）')), [['（', '１，２', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（０－１）')), [['（', '０－１', '）'], '']);
@@ -55,6 +56,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('[a')), [['', '[', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[a]')), [['[', 'a', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[==]')), [['[', '==', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[$]$')), [['', '[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(']')), undefined);
     });
 
@@ -73,7 +75,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('"a')), [['"', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('"a"')), [['"', 'a', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(")"')), [['"', '', '(', '"'], ')"']);
-      assert.deepStrictEqual(inspect(parser('"(("')), [['"', '((', '"'], '']);
+      assert.deepStrictEqual(inspect(parser('"(("')), [['"', '', '((', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"')), [['"', '<span class="paren">(")</span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\\n)"')), [['"', '<span class="paren">(<span class="linebreak"> </span>)</span>', '"'], '']);

package/src/parser/inline/bracket.ts

@@ -9,18 +9,18 @@ import { unshift, push } from 'spica/array';
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
 export const bracket: BracketParser = lazy(() => creator(0, union([
-  surround(str('('), precedence(3, str(index)), str(')')),
-  surround(str('('), precedence(3, some(inline, ')', [[')', 3]])), str(')'), true,
+  surround(str('('), precedence(2, str(index)), str(')')),
+  surround(str('('), precedence(2, some(inline, ')', [[')', 2]])), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
-  surround(str('（'), precedence(3, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
-  surround(str('（'), precedence(3, some(inline, '）', [['）', 3]])), str('）'), true,
+  surround(str('（'), precedence(2, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
+  surround(str('（'), precedence(2, some(inline, '）', [['）', 2]])), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('['), precedence(3, some(inline, ']', [[']', 3]])), str(']'), true,
+  surround(str('['), precedence(2, some(inline, ']', [[']', 2]])), str(']'), true,
     undefined,
     ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
-  surround(str('{'), precedence(3, some(inline, '}', [['}', 3]])), str('}'), true,
+  surround(str('{'), precedence(2, some(inline, '}', [['}', 2]])), str('}'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
   // Control media blinking in editing rather than control confusion of pairs of quote marks.

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

@@ -57,6 +57,7 @@ describe('Unit: parser/inline/comment', () => {
       assert.deepStrictEqual(inspect(parser('[% &amp;copy; %]')), [['<span class="comment"><input type="checkbox"><span>[% &amp;copy; %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% [ %]')), [['<span class="comment"><input type="checkbox"><span>[% [ %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% \\ a %]')), [['<span class="comment"><input type="checkbox"><span>[%  a %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[% $-a %]$')), [['<span class="comment"><input type="checkbox"><span>[% <a class="label" data-label="$-a">$-a</a> %]</span></span>'], '$']);
     });
 
   });

package/src/parser/inline/deletion.ts

@@ -6,7 +6,7 @@ import { blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const deletion: DeletionParser = lazy(() => creator(precedence(2, surround(
+export const deletion: DeletionParser = lazy(() => creator(precedence(1, surround(
   str('~~'),
   some(union([
     some(inline, blankWith('\n', '~~')),

package/src/parser/inline/extension/index.ts

@@ -9,7 +9,7 @@ import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => validate('[#', creator(precedence(3, fmap(indexee(surround(
+export const index: IndexParser = lazy(() => validate('[#', creator(precedence(2, fmap(indexee(surround(
   '[#',
   guard(context => context.syntax?.inline?.index ?? true,
   startTight(
@@ -25,7 +25,7 @@ export const index: IndexParser = lazy(() => validate('[#', creator(precedence(3
   open(stropt(/^\|?/), trimBlankEnd(some(union([
     signature,
     inline,
-  ]), ']', [[/^\\?\n/, 9], [']', 3]])), true)))),
+  ]), ']', [[/^\\?\n/, 9], [']', 2]])), true)))),
   ']',
   false,
   ([, ns], rest) => [[html('a', defrag(ns))], rest])),

package/src/parser/inline/extension/placeholder.ts

@@ -10,9 +10,9 @@ import { unshift } from 'spica/array';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], creator(precedence(3, surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], creator(precedence(2, surround(
   str(/^\[[:^]/),
-  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 3]])),
+  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]])),
   str(']'), false,
   ([as, bs], rest) => [[
     html('span', {

package/src/parser/inline/insertion.ts

@@ -6,7 +6,7 @@ import { blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const insertion: InsertionParser = lazy(() => creator(precedence(2, surround(
+export const insertion: InsertionParser = lazy(() => creator(precedence(1, surround(
   str('++'),
   some(union([
     some(inline, blankWith('\n', '++')),

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, precedence, 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(() => validate(['[', '{'], creator(10, precedence(3, 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(() => validate(['[', '{'], creator(10, prec
           media: false,
           autolink: false,
         }}},
-        trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 3]]))),
+        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()!;
@@ -62,10 +69,35 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], creator(10, prec
     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"`]),
@@ -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

@@ -6,7 +6,7 @@ import { startTight, blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const mark: MarkParser = lazy(() => creator(precedence(2, surround(
+export const mark: MarkParser = lazy(() => creator(precedence(1, surround(
   str('=='),
   startTight(some(union([
     some(inline, blankWith('==')),