securemark 0.293.1 → 0.293.3

package/src/parser/inline/bracket.ts

@@ -1,6 +1,6 @@
 import { BracketParser } from '../inline';
 import { State, Recursion, Backtrack } from '../context';
-import { union, some, recursion, precedence, validate, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
@@ -11,93 +11,119 @@ const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
 const indexF = new RegExp(indexA.source.replace(', ', '[，、]')
   .replace(/[09AZaz.]|\-(?!\w)/g, c => String.fromCodePoint(c.codePointAt(0)! + 0xFEE0)));
 
-export const bracket: BracketParser = lazy(() => validate(/[([{（［｛"]/y, union([
-  surround(
-    str('('),
-    precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
-    str(')'),
-    true,
-    ([as, bs = [], cs], { source, position, range = 0 }) => {
-      const str = source.slice(position - range + 1, position - 1);
-      return indexA.test(str)
-        ? [[as[0], str, cs[0]]]
-        : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
-    },
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('（'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
-    str('）'),
-    true,
-    ([as, bs = [], cs], { source, position, range = 0 }) => {
-      const str = source.slice(position - range + 1, position - 1);
-      return indexF.test(str)
-        ? [[as[0], str, cs[0]]]
-        : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
-    },
-    ([as, bs = []]) => [unshift(as, bs)]),
-  surround(
-    str('['),
-    precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
-    str(']'),
-    true,
-    ([as, bs = [], cs], context) => {
-      if (context.state! & State.link) {
-        const { source, position, range = 0 } = context;
-        const head = position - range;
-        if (context.linebreak !== 0 || source[position] !== '{') {
+export const bracket: BracketParser = lazy(() => union([
+  input => {
+    const { context: { source, position } } = input;
+    switch (source[position]) {
+      case '(':
+        return p1(input);
+      case '（':
+        return p2(input);
+      case '[':
+        return s1(input);
+      case '［':
+        return s2(input);
+      case '{':
+        return c1(input);
+      case '｛':
+        return c2(input);
+      case '"':
+        return d1(input);
+    }
+  }
+])) as any;
+
+const p1 = lazy(() => surround(
+  str('('),
+  precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
+  str(')'),
+  true,
+  ([as, bs = [], cs], { source, position, range = 0 }) => {
+    const str = source.slice(position - range + 1, position - 1);
+    return indexA.test(str)
+      ? [[as[0], str, cs[0]]]
+      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const p2 = lazy(() => surround(
+  str('（'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
+  str('）'),
+  true,
+  ([as, bs = [], cs], { source, position, range = 0 }) => {
+    const str = source.slice(position - range + 1, position - 1);
+    return indexF.test(str)
+      ? [[as[0], str, cs[0]]]
+      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const s1 = lazy(() => surround(
+  str('['),
+  precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
+  str(']'),
+  true,
+  ([as, bs = [], cs], context) => {
+    if (context.state! & State.link) {
+      const { source, position, range = 0 } = context;
+      const head = position - range;
+      if (context.linebreak !== 0 || source[position] !== '{') {
+        setBacktrack(context, [2 | Backtrack.link], head);
+      }
+      else {
+        context.state! ^= State.link;
+        const result = !isBacktrack(context, [1 | Backtrack.link])
+          ? textlink({ context })
+          : undefined;
+        context.position = position;
+        if (!result) {
           setBacktrack(context, [2 | Backtrack.link], head);
         }
-        else {
-          context.state! ^= State.link;
-          const result = !isBacktrack(context, [1 | Backtrack.link])
-            ? textlink({ context })
-            : undefined;
-          context.position = position;
-          if (!result) {
-            setBacktrack(context, [2 | Backtrack.link], head);
-          }
-          context.state! ^= State.link;
-          context.range = range;
-        }
+        context.state! ^= State.link;
+        context.range = range;
       }
-      return [push(unshift(as, bs), cs)];
-    },
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('［'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '］', [['］', 1]]))),
-    str('］'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)]),
-  surround(
-    str('{'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
-    str('}'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('｛'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '｝', [['｝', 1]]))),
-    str('｝'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)]),
-  // 同一行内でしか閉じない以外括弧と同じ挙動
-  surround(
-    str('"'),
-    precedence(2, recursion(Recursion.bracket, some(inline, '"', [['"', 2, false]]))),
-    str('"'),
-    true,
-    ([as, bs = [], cs], context) =>
-      context.linebreak === 0
-        ? [push(unshift(as, bs), cs)]
-        : (context.position -= 1, [unshift(as, bs)]),
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-])));
+    }
+    return [push(unshift(as, bs), cs)];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const s2 = lazy(() => surround(
+  str('［'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '］', [['］', 1]]))),
+  str('］'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const c1 = lazy(() => surround(
+  str('{'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
+  str('}'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const c2 = lazy(() => surround(
+  str('｛'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '｝', [['｝', 1]]))),
+  str('｝'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const d1 = lazy(() => surround(
+  str('"'),
+  // 改行の優先度を構文ごとに変える場合シグネチャの優先度対応が必要
+  precedence(2, recursion(Recursion.bracket, some(inline, /["\n]/y, [['"', 2], ['\n', 3]]))),
+  str('"'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));

package/src/parser/inline/html.ts

@@ -7,7 +7,7 @@ import { str } from '../source';
 import { isLooseNodeStart, blankWith } from '../visibility';
 import { invalid } from '../util';
 import { memoize } from 'spica/memoize';
-import { unshift, push, splice } from 'spica/array';
+import { unshift, push } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
 const tags: readonly string[] = ['wbr', 'bdo', 'bdi'];
@@ -42,10 +42,14 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
             true,
             ([as, bs = [], cs]) => [push(unshift(as, bs), cs)],
             ([as, bs = []]) => [unshift(as, bs)]),
-          precedence(3, recursion(Recursion.inline,
+          // 不可視のHTML構造が可視構造を変化させるべきでない。
+          // 可視のHTMLは優先度変更を検討する。
+          // このため<>は将来的に共通構造を変化させる可能性があり
+          // 共通構造を変更させない非構造文字列としては依然としてエスケープを要する。
+          precedence(0, recursion(Recursion.inline,
           some(union([
-            some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]),
-            open('\n', some(inline, `</${tag}>`, [[`</${tag}>`, 3]]), true),
+            some(inline, blankWith('\n', `</${tag}>`)),
+            open('\n', some(inline, `</${tag}>`), true),
           ])))),
           str(`</${tag}>`),
           true,
@@ -81,7 +85,7 @@ function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | st
     if (bs.length === 0) return ielem('content', `Missing the content`, context);
     if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, context);
   }
-  const attrs = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
+  const [attrs] = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
   if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', context)
   if (as.at(-1) !== '>') return ielem('tag', `Missing the closing symbol ">"`, context);
   return h(tag as 'span', attrs, defrag(bs));
@@ -101,11 +105,12 @@ const requiredAttributes = memoize(
 export function attributes(
   syntax: string,
   spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>> | undefined,
-  params: string[],
-): Record<string, string | undefined> {
+  params: readonly string[],
+): [Record<string, string | undefined>, string[]] {
   assert(spec instanceof Object === false);
   assert(!spec?.['__proto__']);
   assert(!spec?.toString);
+  const remains = [];
   let invalidation = false;
   const attrs: Record<string, string | undefined> = {};
   for (let i = 0; i < params.length; ++i) {
@@ -116,19 +121,25 @@ export function attributes(
       ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
       : undefined;
     invalidation ||= name === '' || !spec || name in attrs;
-    if (name === '' || spec && name in spec && !spec[name]) continue;
-    spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined
-      ? attrs[name] = value ?? ''
-      : invalidation ||= !!spec;
+    if (name === '')continue;
+    if (spec && name in spec && !spec[name]) {
+      remains.push(params[i]);
+      continue;
+    }
+    if (spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined) {
+      attrs[name] = value ?? ''
+    }
+    else {
+      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;
+  return [attrs, remains];
 }
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element

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

@@ -11,14 +11,14 @@ describe('Unit: parser/inline/italic', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('///'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('///a'), ctx), [['///', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('///a ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a  ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a\n///'), ctx), [['///', 'a', '<br>', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a\\ ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a\\\n///'), ctx), [['///', 'a', '<br>', '/', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('///a ///'), ctx), [['///', 'a', ' ', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a  ///'), ctx), [['///', 'a', ' ', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\n///'), ctx), [['///', 'a', '<br>', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\\ ///'), ctx), [['///', 'a', ' ', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\\\n///'), ctx), [['///', 'a', '<br>', '///'], '']);
       assert.deepStrictEqual(inspect(parser('///a/b'), ctx), [['///', 'a', '/b'], '']);
-      assert.deepStrictEqual(inspect(parser('///a//b'), ctx), [['///', 'a', '/', '/b'], '']);
-      assert.deepStrictEqual(inspect(parser('///a*b///'), ctx), [['///', 'a', '*', 'b', '/', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('///a//b'), ctx), [['///', 'a', '//b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a*b///'), ctx), [['///', 'a', '*', 'b', '///'], '']);
       assert.deepStrictEqual(inspect(parser('/// ///'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('/// a///'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('/// a ///'), ctx), undefined);
@@ -53,8 +53,8 @@ describe('Unit: parser/inline/italic', () => {
       assert.deepStrictEqual(inspect(parser('//////a///b'), ctx), [['///', '<i>a</i>', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('//////a////'), ctx), [['///', '<i>a</i>', '/'], '']);
       assert.deepStrictEqual(inspect(parser('//////a////b'), ctx), [['///', '<i>a</i>', '/b'], '']);
-      assert.deepStrictEqual(inspect(parser('//////a/////'), ctx), [['///', '<i>a</i>', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('//////a/////b'), ctx), [['///', '<i>a</i>', '/', '/b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////'), ctx), [['///', '<i>a</i>', '//'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////b'), ctx), [['///', '<i>a</i>', '//b'], '']);
       assert.deepStrictEqual(inspect(parser('//////a//////'), ctx), [['<i><i>a</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('//////a///b///'), ctx), [['<i><i>a</i>b</i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a ///b//////'), ctx), [['<i>a <i>b</i></i>'], '']);

package/src/parser/inline/link.ts

@@ -135,7 +135,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)[0]);
 }
 
 function elem(

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

@@ -14,11 +14,11 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('=='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('==a'), ctx), [['==', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('==a='), ctx), [['==', 'a', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a =='), ctx), [['==', 'a', ' ', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a  =='), ctx), [['==', 'a', ' ', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a\n=='), ctx), [['==', 'a', '<br>', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a\\ =='), ctx), [['==', 'a', ' ', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a\\\n=='), ctx), [['==', 'a', '<br>', '=', '='], '']);
+      assert.deepStrictEqual(inspect(parser('==a =='), ctx), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a  =='), ctx), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a\n=='), ctx), [['==', 'a', '<br>', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\ =='), ctx), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\\n=='), ctx), [['==', 'a', '<br>', '=='], '']);
       assert.deepStrictEqual(inspect(parser('== =='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('== a=='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('== a =='), ctx), undefined);

package/src/parser/inline/math.ts

@@ -11,14 +11,14 @@ export const math: MathParser = lazy(() => rewrite(
   union([
     surround(
       /\$(?={)/y,
-      precedence(5, bracket),
+      precedence(4, bracket),
       '$',
       false, undefined, undefined, [3 | Backtrack.bracket]),
     surround(
       /\$(?![\s{}])/y,
       precedence(2, some(union([
         some(escsource, /\s?\$|[`"{}\n]/y),
-        precedence(5, bracket),
+        precedence(4, bracket),
       ]))),
       /\$(?![-0-9A-Za-z])/y,
       false, undefined, undefined, [3 | Backtrack.bracket]),

package/src/parser/inline/media.ts

@@ -87,7 +87,8 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
     el.setAttribute('alt', text);
     if (!sanitize(el, uri)) return [[el]];
     assert(!el.matches('.invalid'));
-    define(el, attributes('media', optspec, params));
+    const [attrs, linkparams] = attributes('media', optspec, params);
+    define(el, attrs);
     assert(el.matches('img') || !el.matches('.invalid'));
     // Awaiting the generic support for attr().
     if (el.hasAttribute('aspect-ratio')) {
@@ -103,7 +104,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
         context.position = position;
         return [define(link, { class: null, target: '_blank' }, [el])];
       })
-      (subinput(`{ ${INSECURE_URI}${params.join('')} }`, context));
+      (subinput(`{ ${INSECURE_URI}${linkparams.join('')} }`, context));
   })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recursion.terminal, union([

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

@@ -17,7 +17,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[]]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[["]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[(]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[<bdi>]]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[[[%]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[ ]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[ [a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[\n]]'), ctx), undefined);

package/src/parser/inline/remark.ts

@@ -9,8 +9,8 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const remark: RemarkParser = lazy(() => fallback(surround(
   str(/\[%(?=\s)/y),
-  precedence(4, recursion(Recursion.inline,
-  some(union([inline]), /\s%\]/y, [[/\s%\]/y, 4]]))),
+  precedence(3, recursion(Recursion.inline,
+  some(union([inline]), /\s%\]/y, [[/\s%\]/y, 3]]))),
   close(text, str(`%]`)), true,
   ([as, bs = [], cs]) => [[
     html('span', { class: 'remark' }, [

package/src/parser/inline/template.ts

@@ -34,7 +34,7 @@ const bracket: TemplateParser.BracketParser = lazy(() => union([
     undefined, () => [[]], [3 | Backtrack.escbracket]),
   surround(
     str('"'),
-    precedence(2, recursion(Recursion.terminal, some(escsource, '"', [['"', 2, false]]))),
+    precedence(2, recursion(Recursion.terminal, some(escsource, /["\n]/y, [['"', 2], ['\n', 3]]))),
     str('"'),
     true,
     ([as, bs = [], cs], context) =>

package/src/parser/inline.test.ts

@@ -22,7 +22,7 @@ describe('Unit: parser/inline', () => {
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('あ（Ａ）'), ctx), [['あ', '（', 'Ａ', '）'], '']);
       assert.deepStrictEqual(inspect(parser('あ（い）'), ctx), [['あ', '<span class="paren">（い）</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('* a*'), ctx), [['*', ' a', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('* a*'), ctx), [['* a', '*'], '']);
       assert.deepStrictEqual(inspect(parser('** a**'), ctx), [['**', ' a', '**'], '']);
       assert.deepStrictEqual(inspect(parser('*** a***'), ctx), [['***', ' a', '***'], '']);
       assert.deepStrictEqual(inspect(parser('**** a****'), ctx), [['****', ' a', '****'], '']);
@@ -82,19 +82,19 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*++ a ++*'), ctx), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++  a  ++*'), ctx), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*<bdi>`a`</bdi>*'), ctx), [['<em><bdi><code data-src="`a`">a</code></bdi></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a"\nb*'), ctx), [['*', 'a', '"', '<br>', 'b', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('*a"\nb*'), ctx), [['<em>a"<br>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a"\n"("b*'), ctx), [['<em>a"<br>"("b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('"*a\nb*'), ctx), [['"', '<em>a<br>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('"*a\n""b*'), ctx), [['"', '<em>a<br>""b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a\nb*'), ctx), [['"', '*', 'a', '<br>', 'b', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a\n""b*'), ctx), [['"', '*', 'a', '<br>', '"', '"', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"a\n"*b"c*'), ctx), [['"', 'a', '<br>', '"', '*', 'b', '"', 'c', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('"*a**b\nc**"("*'), ctx), [['"', '<em>a<strong>b<br>c</strong>"("</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a"\nb</bdi>'), ctx), [['<bdi>a"<br>b</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('"<bdi>"a\n""b</bdi>"'), ctx), [['"', '<bdi>"a<br>""b</bdi>', '"'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a**b\nc**"("*'), ctx), [['"', '*', 'a', '**', 'b', '<br>', 'c', '**', '"', '(', '"', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a"\nb %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a"<br>b %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('"<bdi>"a\n""b</bdi>"'), ctx), [['"', '<span class="invalid">&lt;bdi&gt;</span>', '"', 'a', '<br>', '"', '"', 'b', '</bdi', '>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>*<bdi>a</bdi>*</bdi>'), ctx), [['<bdi><em><bdi>a</bdi></em></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>((<bdi>((a))</bdi>))</bdi>'), ctx), [['<bdi><sup class="annotation"><span><bdi><span class="paren">((a))</span></bdi></span></sup></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>'), ctx), [['<bdi><sup class="reference"><span><bdi>[[a]]</bdi></span></sup></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>[#</bdi>]'), ctx), [['<bdi>[#</bdi>', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('"<bdi>("")</bdi>'), ctx), [['"', '<bdi><span class="paren">("")</span></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>[#</bdi>]'), ctx), [['<span class="invalid">&lt;bdi&gt;[#&lt;/bdi&gt;]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('"<bdi>("")</bdi>'), ctx), [['"', '<span class="invalid">&lt;bdi&gt;(</span>', '"', '"', ')', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser('++\na\n++\n~~\nb\n~~\nc'), ctx), [['<ins><br>a</ins>', '<br>', '<del><br>b</del>', '<br>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]'), ctx), [['[', '<a class="account" href="/@a">@a</a>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[#1][#2]'), ctx), [['<a class="index" href="#index::1">1</a>', '<a class="index" href="#index::2">2</a>'], '']);
@@ -121,11 +121,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('{}'), ctx), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a}'), ctx), [['<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('{{a}}'), ctx), [['<span class="template">{{a}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{}'), ctx), [['!', '{', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{a}'), ctx), [['!', '<a class="url" href="a">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{{a}}'), ctx), [['!', '<span class="template">{{a}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{{{a}}}'), ctx), [['!', '<span class="template">{{{a}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!!{a}'), ctx), [['!', '!', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!{}'), ctx), [['!', '{', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('!{a}'), ctx), [['!', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!{{a}}'), ctx), [['!', '<span class="template">{{a}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('!{{{a}}}'), ctx), [['!', '<span class="template">{{{a}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('!!{a}'), ctx), [['!', '!', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('${a}'), ctx), [['$', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('${{a}}'), ctx), [['$', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${{{a}}}'), ctx), [['$', '<span class="template">{{{a}}}</span>'], '']);
@@ -165,16 +165,16 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('"[% *"*"*'), ctx), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]'), ctx), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('"{{""}}'), ctx), [['"', '{', '{', '"', '"', '}', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('[#http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::http://host/(&lt;bdi&gt;)">http://host/(&lt;bdi&gt;)</a>', '<', '/bdi', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#@a/http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/(&lt;bdi&gt;)</a>', '<', '/bdi', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|<bdi>]</bdi>'), ctx), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '|', '<bdi>]</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[#a|<bdi>]</bdi>'), ctx), [['[', '[', '<a class="hashtag" href="/hashtags/a">#a</a>', '|', '<bdi>]</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::http://host/(&lt;bdi&gt;)">http://host/(&lt;bdi&gt;)</a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#@a/http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/(&lt;bdi&gt;)</a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|<bdi>]</bdi>'), ctx), [['<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[#a|<bdi>]</bdi>'), ctx), [['[', '<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
     });
 
     it('uri', () => {
       assert.deepStrictEqual(inspect(parser('\nhttp://host'), ctx), [['<br>', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('0http://host'), ctx), [['0http:', '/', '/host'], '']);
-      assert.deepStrictEqual(inspect(parser('0aAhttp://host'), ctx), [['0aAhttp:', '/', '/host'], '']);
+      assert.deepStrictEqual(inspect(parser('0http://host'), ctx), [['0http:', '//host'], '']);
+      assert.deepStrictEqual(inspect(parser('0aAhttp://host'), ctx), [['0aAhttp:', '//host'], '']);
       assert.deepStrictEqual(inspect(parser('?http://host'), ctx), [['?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('0!http://host'), ctx), [['0', '!', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('0?http://host'), ctx), [['0', '?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
@@ -196,7 +196,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a@b*'), ctx), [['<em><a class="email" href="mailto:a@b">a@b</a></em>'], '']);
       assert.deepStrictEqual(inspect(parser('(a@b)'), ctx), [['<span class="paren">(<a class="email" href="mailto:a@b">a@b</a>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser(' a@b'), ctx), [[' ', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('++a++b@c++'), ctx), [['<ins>a</ins>', '<a class="email" href="mailto:b@c">b@c</a>', '+', '+'], '']);
+      assert.deepStrictEqual(inspect(parser('++a@b++'), ctx), [['<ins><a class="email" href="mailto:a@b">a@b</a></ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a++b@c++'), ctx), [['<ins>a</ins>', '<a class="email" href="mailto:b@c">b@c</a>', '++'], '']);
     });
 
     it('channel', () => {
@@ -209,7 +210,7 @@ describe('Unit: parser/inline', () => {
 
     it('account', () => {
       assert.deepStrictEqual(inspect(parser('@a'), ctx), [['<a class="account" href="/@a">@a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@http://host'), ctx), [['@http', ':', '/', '/host'], '']);
+      assert.deepStrictEqual(inspect(parser('@http://host'), ctx), [['@http', '://host'], '']);
       assert.deepStrictEqual(inspect(parser('_@a'), ctx), [['_', '<a class="account" href="/@a">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_@a_'), ctx), [['_', '<a class="account" href="/@a">@a</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('*@a*'), ctx), [['<em><a class="account" href="/@a">@a</a></em>'], '']);
@@ -221,7 +222,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('#a#'), ctx), [['#a', '#'], '']);
       assert.deepStrictEqual(inspect(parser('#a#b'), ctx), [['#a', '#b'], '']);
       assert.deepStrictEqual(inspect(parser('#a'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('#http://host'), ctx), [['#http', ':', '/', '/host'], '']);
+      assert.deepStrictEqual(inspect(parser('#http://host'), ctx), [['#http', '://host'], '']);
       assert.deepStrictEqual(inspect(parser('#a\nb\n#c\n[#d]'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>', '<br>', 'b', '<br>', '<a class="hashtag" href="/hashtags/c">#c</a>', '<br>', '<a class="index" href="#index::d">d</a>'], '']);
       assert.deepStrictEqual(inspect(parser('##a'), ctx), [['##a'], '']);
       assert.deepStrictEqual(inspect(parser('_#a'), ctx), [['_', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);