securemark 0.290.2 → 0.291.0

package/src/parser/inline/code.ts

@@ -1,12 +1,12 @@
 import { CodeParser } from '../inline';
-import { validate, getBacktrack, setBacktrack, match } from '../../combinator';
+import { validate, isBacktrack, setBacktrack, match } from '../../combinator';
 import { Backtrack } from '../context';
 import { html } from 'typed-dom/dom';
 
 export const code: CodeParser = validate(
   ({ source, context }) =>
     source[0] === '`' &&
-    !getBacktrack(context, [1 | Backtrack.bracket], source),
+    !isBacktrack(context, [1 | Backtrack.bracket], source),
   match(
     /^(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|$|\n)/,
     ([whole, , body, closer]) => ({ source, context }) =>

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

@@ -5,50 +5,66 @@ import { union, inits, some, precedence, state, constraint, validate, surround,
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { unsafehtmlentity } from '../htmlentity';
-import { text, str } from '../../source';
+import { txt, str } from '../../source';
 import { tightStart, trimBlankNodeEnd } from '../../visibility';
-import { unshift } from 'spica/array';
+import { unshift, push } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => constraint(State.index, false, fmap(indexee(surround(
-  '[#',
-  precedence(1, state(State.linkers | State.media,
+export const index: IndexParser = lazy(() => constraint(State.index, fmap(indexee(surround(
+  str('[#'),
+  precedence(1, state(State.linkers,
   tightStart(
   some(inits([
     inline,
     signature,
   ]), ']', [[']', 1]])))),
-  ']',
+  str(']'),
   false,
-  ([, ns], rest, context) =>
-    context.linebreak === undefined &&
-    trimBlankNodeEnd(ns).length > 0
-      ? [[html('a', { 'data-index': dataindex(ns) }, defrag(ns))], rest]
-      : undefined,
-  undefined,
+  ([as, bs, cs], rest, context) => {
+    if (context.linebreak === 0 && trimBlankNodeEnd(bs).length > 0) {
+      return [[html('a', { 'data-index': dataindex(bs) }, defrag(bs))], rest];
+    }
+    return (context.state! & State.linkers) === State.linkers
+      ? [push(push(unshift(as, bs), cs), ['']), rest]
+      : undefined;
+  },
+  ([as, bs], rest, context) => {
+    return (context.state! & State.linkers) === State.linkers
+      ? [push(unshift(as, bs), ['']), rest]
+      : undefined;
+  },
   [3 | Backtrack.bracket])),
-  ([el]: [HTMLAnchorElement]) => [
-    define(el,
-      {
-        id: el.id ? null : undefined,
-        class: 'index',
-        href: el.id ? `#${el.id}` : undefined,
-      }),
-  ])));
+  ns => {
+    if (ns.length === 1) {
+      const el = ns[0] as HTMLElement;
+      return [
+        define(el, {
+          id: el.id ? null : undefined,
+          class: 'index',
+          href: el.id ? `#${el.id}` : undefined,
+        })
+      ];
+    }
+    else {
+      assert(ns.at(-1) === '');
+      ns.pop();
+      return ns;
+    }
+  })));
 
 export const signature: IndexParser.SignatureParser = lazy(() => validate('|', surround(
   str(/^\|(?!\\?\s)/),
-  tightStart(some(union([inline]), ']')),
+  tightStart(some(union([inline]), ']', [[']', 1]])),
   /^(?=])/,
   false,
   (_, rest, context) => {
     //context.offset ??= 0;
     //context.offset += rest.length;
-    const sig = eval(parser({ source: context.recent![1], context }), []).join('');
+    const text = eval(sig({ source: context.recent![1], context }), []).join('');
     //context.offset -= rest.length;
-    const index = identity('index', undefined, sig)?.slice(7);
+    const index = identity('index', undefined, text)?.slice(7);
     return index
       ? [[html('span', { class: 'indexer', 'data-index': index })], rest]
       : undefined;
@@ -57,7 +73,7 @@ export const signature: IndexParser.SignatureParser = lazy(() => validate('|', s
 
 export function dataindex(ns: readonly (string | HTMLElement)[]): string | undefined {
   if (ns.length === 0) return;
-  for (let i = ns.length - 1; i >= 0; --i) {
+  for (let i = ns.length; i--;) {
     const node = ns[i];
     if (typeof node === 'string') return;
     if (i === ns.length - 1 && ['UL', 'OL'].includes(node.tagName)) continue;
@@ -66,7 +82,7 @@ export function dataindex(ns: readonly (string | HTMLElement)[]): string | undef
   }
 }
 
-const parser = some(union([
+const sig: IndexParser.SignatureParser.InternalParser = some(union([
   unsafehtmlentity,
-  text,
+  txt,
 ]));

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

@@ -5,7 +5,10 @@ import { define } from 'typed-dom/dom';
 
 export function indexee<P extends Parser<unknown, MarkdownParser.Context>>(parser: P): P;
 export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>): Parser<HTMLElement> {
-  return fmap(parser, ([el], _, { id }) => [define(el, { id: identity('index', id, el), 'data-index': null })]);
+  return fmap(parser, (ns, _, { id }) =>
+    ns.length === 1
+      ? [define(ns[0], { id: identity('index', id, ns[0]), 'data-index': null })]
+      : ns);
 }
 
 const MAX = 60;
@@ -130,8 +133,8 @@ export function signature(source: Element | DocumentFragment): string {
       case 'label':
         el.replaceWith(`[$${el.getAttribute('data-label')!.replace('$', '')}]`);
         continue;
-      case 'remark':
       case 'checkbox':
+      case 'remark':
       case 'annotation':
       case 'reference':
         el.remove();
@@ -163,8 +166,8 @@ export function text(source: Element | DocumentFragment): string {
       case 'math':
         el.replaceWith(el.getAttribute('data-src')!);
         continue;
-      case 'remark':
       case 'checkbox':
+      case 'remark':
       case 'annotation':
       case 'reference':
         el.remove();

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

@@ -11,7 +11,7 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(union([
   body,
 ]));
 
-export const label: ExtensionParser.LabelParser = constraint(State.label, false, fmap(
+export const label: ExtensionParser.LabelParser = constraint(State.label, fmap(
   union([
     surround('[', body, ']', false, undefined, undefined, [1 | Backtrack.bracket, 1]),
     body,

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

@@ -23,6 +23,8 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<a,b>')), undefined);
       assert.deepStrictEqual(inspect(parser('<a, b>')), undefined);
       assert.deepStrictEqual(inspect(parser('<T>')), [['<span class="invalid">&lt;T&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr/>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<wbr />')), [['<span class="invalid">&lt;wbr /&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>')), [['<span class="invalid">&lt;bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>z')), [['<span class="invalid">&lt;bdi&gt;z</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi></bdi>')), [['<span class="invalid">&lt;bdi&gt;&lt;/bdi&gt;</span>'], '']);
@@ -41,23 +43,29 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<BDI>a</bdi>')), [['<span class="invalid">&lt;BDI&gt;</span>'], 'a</bdi>']);
       assert.deepStrictEqual(inspect(parser('</bdi>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdi/>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdi />')), [['<span class="invalid">&lt;bdi /&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<b><b><b>a</b></b></b>')), [['<span class="invalid">&lt;b&gt;<span class="invalid">&lt;b&gt;<span class="invalid">&lt;b&gt;a&lt;/b&gt;</span>&lt;/b&gt;</span>&lt;/b&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi><bdi><bdi>a</bdi></bdi></bdi>')), [['<bdi><bdi><bdi>a</bdi></bdi></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<x a="*b*"')), undefined);
+      assert.deepStrictEqual(inspect(parser('<x a="*b*"')), [['<span class="invalid">&lt;x a="*b*"</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<x a="*b*">')), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<x a="*b*">c')), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], 'c']);
-      assert.deepStrictEqual(inspect(parser('<bdi a="*b*"')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdi a="*b*"')), [['<span class="invalid">&lt;bdi a="*b*"</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi a="*b*">')), [['<span class="invalid">&lt;bdi a="*b*"&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi a="*b*">c')), [['<span class="invalid">&lt;bdi a="*b*"&gt;c</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*>d</bdi>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *>*c*')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *>*c*</bdi>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*')), [['<span class="invalid">&lt;bdi a b="*" *c*</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*>')), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*>d</bdi>')), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;d&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *>*c*')), [['<span class="invalid">&lt;bdi a b="*" *&gt;<em>c</em></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *>*c*</bdi>')), [['<span class="invalid">&lt;bdi a b="*" *&gt;<em>c</em>&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser(' <bdi>a</bdi>')), undefined);
     });
 
     it('basic', () => {
+      assert.deepStrictEqual(inspect(parser('<wbr>')), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr >')), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr>a')), [['<wbr>'], 'a']);
+      assert.deepStrictEqual(inspect(parser('<bdi >a</bdi>')), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>')), [['<bdi>a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi> a</bdi>')), [['<bdi> a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi> a </bdi>')), [['<bdi> a </bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>  a  </bdi>')), [['<bdi>  a  </bdi>'], '']);
@@ -71,7 +79,6 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdi>a\n </bdi>')), [['<bdi>a </bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a\n<wbr></bdi>')), [['<bdi>a<wbr></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a\nb</bdi>')), [['<bdi>a<br>b</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<wbr>a')), [['<wbr>'], 'a']);
     });
 
     it('nest', () => {
@@ -87,31 +94,27 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdi>a<a>b</a>c</bdi>')), [['<bdi>a<span class="invalid">&lt;a&gt;b&lt;/a&gt;</span>c</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<img>')), [['<span class="invalid">&lt;img&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi><img></bdi>')), [['<bdi><span class="invalid">&lt;img&gt;</span></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<img />')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi><img /></bdi>')), [['<bdi>&lt;img /&gt;</bdi>'], '']);
     });
 
     it('attribute', () => {
       assert.deepStrictEqual(inspect(parser('<bdi\n>a</bdi>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi >a</bdi>')), [['<bdi>a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi \n>a</bdi>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>')), [['<bdi>a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi __proto__>a</bdi>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdi \n>a</bdi>')), [['<span class="invalid">&lt;bdi <br>&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi __proto__>a</bdi>')), [['<span class="invalid">&lt;bdi __proto__&gt;a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi constructor>a</bdi>')), [['<span class="invalid">&lt;bdi constructor&gt;a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi toString>a</bdi>')), [['<span class="invalid">&lt;bdi toString&gt;a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi X>a</bdi>')), [['<span class="invalid">&lt;bdi X&gt;a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi x>a</bdi>')), [['<span class="invalid">&lt;bdi x&gt;a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo>a</bdo>')), [['<span class="invalid">&lt;bdo&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo >a</bdo>')), [['<span class="invalid">&lt;bdo &gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo __proto__>a</bdo>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdo __proto__>a</bdo>')), [['<span class="invalid">&lt;bdo __proto__&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo constructor>a</bdo>')), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo toString>a</bdo>')), [['<span class="invalid">&lt;bdo toString&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo X>a</bdo>')), [['<span class="invalid">&lt;bdo X&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo x>a</bdo>')), [['<span class="invalid">&lt;bdo x&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir>a</bdo>')), [['<span class="invalid">&lt;bdo dir&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=>a</bdo>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=rtl>a</bdo>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=">a</bdo>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdo dir=>a</bdo>')), [['<span class="invalid">&lt;bdo dir=&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdo dir=rtl>a</bdo>')), [['<span class="invalid">&lt;bdo dir=rtl&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdo dir=">a</bdo>')), [['<span class="invalid">&lt;bdo dir="&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="">a</bdo>')), [['<span class="invalid">&lt;bdo dir=""&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" dir="rtl">a</bdo>')), [['<span class="invalid">&lt;bdo dir="rtl" dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo diR="rtl">a</bdo>')), [['<span class="invalid">&lt;bdo diR="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
@@ -120,7 +123,7 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl"  >a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo  dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr\n>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<wbr >')), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr \n>')), [['<span class="invalid">&lt;wbr </span>'], '\n>']);
       assert.deepStrictEqual(inspect(parser('<wbr constructor>')), [['<span class="invalid">&lt;wbr constructor&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr X>')), [['<span class="invalid">&lt;wbr X&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr x>')), [['<span class="invalid">&lt;wbr x&gt;</span>'], '']);

package/src/parser/inline/html.ts

@@ -1,5 +1,5 @@
 import { HTMLParser } from '../inline';
-import { Recursion, Backtrack } from '../context';
+import { Recursion } from '../context';
 import { union, subsequence, some, recursion, precedence, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
@@ -9,8 +9,9 @@ import { memoize } from 'spica/memoize';
 import { unshift, push, splice } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
-const tags = Object.freeze(['bdo', 'bdi']);
+const tags = Object.freeze(['wbr', 'bdo', 'bdi']);
 const attrspecs = {
+  wbr: {},
   bdo: {
     dir: Object.freeze(['ltr', 'rtl']),
   },
@@ -24,48 +25,110 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
       str(/^<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/i),
       some(union([attribute])),
-      str(/^[^\S\n]*>/), true,
+      open(str(/^[^\S\n]*/), str('>'), true),
+      true,
       ([as, bs = [], cs], rest) =>
-        as[0].slice(1) === 'wbr' && bs.length === 0
-          ? [[h(as[0].slice(1) as 'wbr')], rest]
-          : [[elem(as[0].slice(1), push(unshift(as, bs), cs), [], [])], rest],
-      undefined,
-      [3 | Backtrack.bracket]),
+        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [])], rest],
+      ([as, bs = []], rest) =>
+        [[elem(as[0].slice(1), false, unshift(as, bs), [], [])], rest]),
     match(
       new RegExp(String.raw`^<(${TAGS.join('|')})(?=[^\S\n]|>)`),
       memoize(
       ([, tag]) =>
         surround<HTMLParser.TagParser, string>(
           surround(
-            str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true,
-            undefined, undefined, [3 | Backtrack.bracket]),
+            str(`<${tag}`), some(attribute), open(str(/^[^\S\n]*/), str('>'), true),
+            true,
+            ([as, bs = [], cs], rest) => [push(unshift(as, bs), cs), rest],
+            ([as, bs = []], rest) => [unshift(as, bs), rest]),
           precedence(3, recursion(Recursion.inline,
           subsequence([
             focus(/^[^\S\n]*\n/, some(inline)),
             some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]), true)),
           ]))),
-          str(`</${tag}>`), true,
+          str(`</${tag}>`),
+          true,
           ([as, bs = [], cs], rest) =>
-            [[elem(tag, as, bs, cs)], rest],
+            [[elem(tag, true, as, bs, cs)], rest],
           ([as, bs = []], rest) =>
-            [[elem(tag, as, bs, [])], rest]),
+            [[elem(tag, true, as, bs, [])], rest]),
       ([, tag]) => tag,
       new Map())),
     surround(
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/^<[a-z]+(?=[^\S\n]|>)/i),
+      str(/^<[a-z]{1,16}(?=[^\S\n]|>)/i),
       some(union([attribute])),
-      str(/^[^\S\n]*>/), true,
+      open(str(/^[^\S\n]*/), str('>'), true),
+      true,
       ([as, bs = [], cs], rest) =>
-        [[elem(as[0].slice(1), push(unshift(as, bs), cs), [], [])], rest],
-      undefined,
-      [3 | Backtrack.bracket]),
+        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [])], rest],
+      ([as, bs = []], rest) =>
+        [[elem(as[0].slice(1), false, unshift(as, bs), [], [])], rest]),
   ])));
 
 export const attribute: HTMLParser.AttributeParser = union([
-  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="[^"\n]*")?(?=[^\S\n]|>)/i),
+  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/i),
+  str(/^[^\S\n]+[^\s<>]+/),
 ]);
 
+function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | string)[], cs: string[]): HTMLElement {
+  assert(as.length > 0);
+  assert(as[0][0] === '<');
+  if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, as, bs, cs);
+  if (content) {
+    if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, as, bs, cs);
+    if (bs.length === 0) return ielem('content', `Missing the content`, as, bs, cs);
+    if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, as, bs, cs);
+  }
+  const attrs = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -2 : as.length));
+  if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', as, bs, cs)
+  if (as.at(-1) !== '>') return ielem('tag', `Missing the closing bracket ">"`, as, bs, cs);
+  return h(tag as 'span', attrs, defrag(bs));
+}
+
+function ielem(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
+  return h('span',
+    { class: 'invalid', ...invalid('html', type, message) },
+    defrag(push(unshift(as, bs), cs)));
+}
+
+const requiredAttributes = memoize(
+  (spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>>) =>
+    Object.entries(spec).flatMap(([k, v]) => v && Object.isFrozen(v) ? [k] : []),
+  new WeakMap());
+
+export function attributes(
+  syntax: string,
+  spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>> | undefined,
+  params: string[],
+): Record<string, string | undefined> {
+  assert(spec instanceof Object === false);
+  assert(!spec?.['__proto__']);
+  assert(!spec?.toString);
+  let invalidation = false;
+  const attrs: Record<string, string | undefined> = {};
+  for (let i = 0; i < params.length; ++i) {
+    const param = params[i].trimStart();
+    const name = param.split('=', 1)[0];
+    const value = param !== name
+      ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
+      : undefined;
+    invalidation ||= !spec || name in attrs;
+    if (spec && name in spec && !spec[name]) continue;
+    spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined
+      ? attrs[name] = value ?? ''
+      : invalidation ||= !!spec;
+    assert(!(name in {} && attrs.hasOwnProperty(name)));
+    splice(params, i--, 1);
+  }
+  invalidation ||= !!spec && !requiredAttributes(spec).every(name => name in attrs);
+  if (invalidation) {
+    attrs['class'] = 'invalid';
+    Object.assign(attrs, invalid(syntax, 'argument', 'Invalid argument'));
+  }
+  return attrs;
+}
+
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element
 // [...document.querySelectorAll('tbody > tr > td:first-child')].map(el => el.textContent.slice(1, -1))
 const TAGS = Object.freeze([
@@ -206,62 +269,3 @@ const TAGS = Object.freeze([
   "tt",
   "xmp",
 ]);
-
-function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: string[]): HTMLElement {
-  assert(as.length > 0);
-  assert(as[0][0] === '<' && as.at(-1)!.slice(-1) === '>');
-  if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, as, bs, cs);
-  if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, as, bs, cs);
-  if (bs.length === 0) return ielem('content', `Missing the content`, as, bs, cs);
-  if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, as, bs, cs);
-  const attrs = attributes('html', [], attrspecs[tag], as.slice(1, -1));
-  return /(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')
-    ? ielem('attribute', 'Invalid HTML attribute', as, bs, cs)
-    : h(tag as 'span', attrs, defrag(bs));
-}
-
-function ielem(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
-  return h('span',
-    { class: 'invalid', ...invalid('html', type, message) },
-    defrag(push(unshift(as, bs), cs)));
-}
-
-const requiredAttributes = memoize(
-  (spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>>) =>
-    Object.entries(spec).flatMap(([k, v]) => v && Object.isFrozen(v) ? [k] : []),
-  new WeakMap());
-
-export function attributes(
-  syntax: string,
-  classes: readonly string[],
-  spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>> | undefined,
-  params: string[],
-): Record<string, string | undefined> {
-  assert(spec instanceof Object === false);
-  assert(!spec?.['__proto__']);
-  assert(!spec?.toString);
-  let invalidation = false;
-  const attrs: Record<string, string | undefined> = {};
-  for (let i = 0; i < params.length; ++i) {
-    const param = params[i].trim();
-    const name = param.split('=', 1)[0];
-    const value = param !== name
-      ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
-      : undefined;
-    invalidation ||= !spec || name in attrs;
-    if (spec && name in spec && !spec[name]) continue;
-    spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined
-      ? attrs[name] = value ?? ''
-      : invalidation ||= !!spec;
-    assert(!(name in {} && attrs.hasOwnProperty(name)));
-    splice(params, i--, 1);
-  }
-  invalidation ||= !!spec && !requiredAttributes(spec).every(name => name in attrs);
-  if (invalidation) {
-    attrs['class'] = classes.length === 0
-      ? 'invalid'
-      : `${classes.join(' ')}${classes.includes('invalid') ? '' : ' invalid'}`;
-    Object.assign(attrs, invalid(syntax, 'argument', 'Invalid argument'));
-  }
-  return attrs;
-}

package/src/parser/inline/link.ts

@@ -16,8 +16,8 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.link, false, creation(10,
-  precedence(1, state(State.linkers | State.media,
+export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.link, creation(10,
+  precedence(1, state(State.linkers,
   bind(subsequence([
     dup(surround(
       '[',
@@ -25,11 +25,13 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
       ']',
       true,
       ([, ns = []], rest, context) =>
-        context.linebreak === undefined
+        context.linebreak === 0
           ? [push(ns, [Command.Escape]), rest]
           : undefined,
       undefined,
-      [3 | Backtrack.link, 3 | Backtrack.bracket])),
+      [3 | Backtrack.link, 2 | Backtrack.ruby, 3 | Backtrack.bracket])),
+    // `{ `と`{`で個別にバックトラックが発生し+1nされる。
+    // 自己再帰的にパースしてもオプションの不要なパースによる計算量の増加により相殺される。
     dup(surround(
       /^{(?![{}])/,
       inits([uri, some(option)]),
@@ -41,7 +43,8 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
     if (content.at(-1) === Command.Escape) {
       content.pop();
       if (params === undefined) {
-        return void setBacktrack(context, [2 | Backtrack.link], context.recent!.reduce((a, b) => a + b.length, 0));
+        const head = context.recent!.reduce((a, b) => a + b.length, rest.length);
+        return void setBacktrack(context, [2 | Backtrack.link], head);
       }
     }
     else {
@@ -54,7 +57,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
     return [[parse(defrag(content), params, context)], rest];
   }))))));
 
-export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media, false, validate(['[', '{'], creation(10,
+export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media, validate(['[', '{'], creation(10,
   state(State.linkers,
   bind(reverse(sequence([
     dup(surround(
@@ -90,8 +93,8 @@ export const uri: LinkParser.ParameterParser.UriParser = union([
 
 export const option: LinkParser.ParameterParser.OptionParser = union([
   fmap(str(/^[^\S\n]+nofollow(?=[^\S\n]|})/), () => [` rel="nofollow"`]),
-  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|})/),
-  fmap(str(/^[^\S\n]+[^\s{}]+/), opt => [` \\${opt.slice(1)}`]),
+  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|})/i),
+  str(/^[^\S\n]+[^\s{}]+/),
 ]);
 
 function parse(
@@ -119,7 +122,7 @@ function parse(
     context.host?.origin || location.origin);
   return el.classList.contains('invalid')
     ? el
-    : define(el, attributes('link', [], optspec, params));
+    : define(el, attributes('link', optspec, params));
 }
 
 function elem(

package/src/parser/inline/mark.ts

@@ -8,7 +8,7 @@ import { repeat } from '../util';
 import { push } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mark, false, validate('==',
+export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mark, validate('==',
   precedence(0, state(State.mark, repeat('==', surround(
     '',
     recursion(Recursion.inline,

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

@@ -83,6 +83,7 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$\\huge0$')), [['<span class="invalid" translate="no">$\\huge0$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$\\Begin{}$')), [['<span class="invalid" translate="no">$\\Begin{}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\begin}$')), [['<span class="invalid" translate="no">${\\begin}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$http://host$')), undefined);
       assert.deepStrictEqual(inspect(parser(' ${a}$')), undefined);
     });
 

package/src/parser/inline/math.ts

@@ -1,7 +1,7 @@
 import { MathParser } from '../inline';
-import { Recursion } from '../context';
+import { Backtrack, Recursion } from '../context';
 import { union, some, recursion, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
-import { escsource, unescsource, str } from '../source';
+import { escsource, str } from '../source';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
@@ -9,14 +9,23 @@ const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
 export const math: MathParser = lazy(() => validate('$', rewrite(
   union([
-    surround('$', precedence(5, bracket), '$'),
+    surround(
+      /^\$(?={)/,
+      precedence(5, bracket),
+      '$',
+      false, undefined, undefined, [3 | Backtrack.bracket]),
     surround(
       /^\$(?![\s{}])/,
       precedence(2, some(union([
-        bracket,
-        focus(/^(?:[ ([](?!\$)|\\[\\{}$]?|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/, some(unescsource)),
+        precedence(5, bracket),
+        some(focus(
+          /^(?:[ ([](?!\$)|\\[\\{}$#]?|[!%&')\x2A-\x5A\]^_\x61-\x7A|~])/,
+          escsource,
+          false),
+          '://'),
       ]))),
-      /^\$(?![0-9A-Za-z])/),
+      /^\$(?![0-9A-Za-z])/,
+      false, undefined, undefined, [3 | Backtrack.bracket]),
   ]),
   ({ source, context: { caches: { math: cache } = {} } }) => [[
     cache?.get(source)?.cloneNode(true) ||
@@ -26,8 +35,8 @@ export const math: MathParser = lazy(() => validate('$', rewrite(
         : {
             class: 'invalid',
             translate: 'no',
-          ...invalid('math', 'content',
-            `"${source.match(forbiddenCommand)![0]}" command is forbidden`),
+            ...invalid('math', 'content',
+              `"${source.match(forbiddenCommand)![0]}" command is forbidden`),
           },
       source)
   ], ''])));
@@ -37,7 +46,7 @@ const bracket: MathParser.BracketParser = lazy(() => surround(
   recursion(Recursion.terminal,
   some(union([
     bracket,
-    some(escsource, /^[{}$\n]/),
+    some(escsource, /^[{}$#\n]/),
   ]))),
   str('}'),
   true));