securemark 0.234.3 → 0.235.2

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

@@ -20,13 +20,19 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#\\]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a')), undefined);
       assert.deepStrictEqual(inspect(parser('[#*a\nb*]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a\n|#b]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a|#\n]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a|#\\\n]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a|#(\n)]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#a|#(\\\n)]')), undefined);
       assert.deepStrictEqual(inspect(parser('[# |]')), undefined);
       assert.deepStrictEqual(inspect(parser('[# |#]')), undefined);
       assert.deepStrictEqual(inspect(parser('[# |#b]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# |# ]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[# |# b]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a|]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a|#]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a|#b]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a|# ]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[# a|# b]')), undefined);
       assert.deepStrictEqual(inspect(parser(' [#a]')), undefined);
     });
 
@@ -64,26 +70,21 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#|]')), [['<a class="index" href="#index:|">|</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#|#]')), [['<a class="index" href="#index:|#">|#</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#|#b]')), [['<a class="index" href="#index:|#b">|#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|]')), [['<a class="index" href="#index:a|">a|</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#]')), [['<a class="index" href="#index:a|#">a|#</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|# ]')), [['<a class="index" href="#index:a|#">a|#</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#\\ ]')), [['<a class="index" href="#index:a|#">a|#</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b  ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#\\b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#*b*]')), [['<a class="index" href="#index:*b*">a<span class="indexer" data-index="*b*"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#b  c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#[]]')), [['<a class="index" href="#index:[]">a<span class="indexer" data-index="[]"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#&copy;]')), [['<a class="index" href="#index:&amp;copy;">a<span class="indexer" data-index="&amp;copy;"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|#b]')), [['<a class="index" href="#index:a|#b">a|#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a |]')), [['<a class="index" href="#index:a_|">a |</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a |#]')), [['<a class="index" href="#index:a_|#">a |#</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |# ]')), [['<a class="index" href="#index:a_|#">a |#</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#\\ ]')), [['<a class="index" href="#index:a_|#">a |#</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a |#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#b ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#b  ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#\\b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#*b*]')), [['<a class="index" href="#index:*b*">a<span class="indexer" data-index="*b*"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#b c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#b  c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#[]]')), [['<a class="index" href="#index:[]">a<span class="indexer" data-index="[]"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a |#&copy;]')), [['<a class="index" href="#index:&amp;copy;">a<span class="indexer" data-index="&amp;copy;"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a  |#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a &nbsp;|#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a <wbr>|#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a [# b #]|#b]')), [['<a class="index" href="#index:b">a <span class="comment"><input type="checkbox"><span>[# b #]</span></span><span class="indexer" data-index="b"></span></a>'], '']);
     });
 
   });

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

@@ -23,11 +23,10 @@ export const index: IndexParser = lazy(() => creator(validate('[#', ']', '\n', f
     media: false,
     autolink: false,
   }}},
-  open(str(/^\|?/, false),
   some(union([
     signature,
     inline,
-  ]), ']', /^\\?\n/), true)))),
+  ]), ']', /^\\?\n/)))),
   ']'),
   ns => [html('a', trimNodeEnd(defrag(ns)))])),
   ([el]: [HTMLAnchorElement]) => [
@@ -41,8 +40,8 @@ export const index: IndexParser = lazy(() => creator(validate('[#', ']', '\n', f
   ]))));
 
 const signature: IndexParser.SignatureParser = lazy(() => creator(fmap(open(
-  '|#',
-  startTight(some(union([bracket, txt]), ']', /^\\?\n/))),
+  /^\s+\|#/,
+  startTight(some(union([bracket, txt]), ']'))),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity(join(ns)).slice(6) }),
   ])));

package/src/parser/inline/extension/indexer.test.ts

@@ -15,6 +15,7 @@ describe('Unit: parser/inline/extension/indexer', () => {
       assert.deepStrictEqual(inspect(parser(' [#]')), undefined);
       assert.deepStrictEqual(inspect(parser(' [#]]')), undefined);
       assert.deepStrictEqual(inspect(parser(' [#a]]')), undefined);
+      assert.deepStrictEqual(inspect(parser(' [#&a;]')), undefined);
     });
 
     it('valid', () => {

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

@@ -10,6 +10,7 @@ export const indexer: ExtensionParser.IndexerParser = creator(fmap(verify(surrou
   }}},
   union([index])),
   /^\s*$/),
+  // Indexer is invisible but invalids must be visible.
   ([el]) => el.getElementsByClassName('invalid').length === 0),
   ([el]) => [
     html('span', { class: 'indexer', 'data-index': el.getAttribute('href')!.slice(7) }),

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

@@ -59,11 +59,14 @@ describe('Unit: parser/inline/html', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('<small> a</small>')), [['<small> a</small>'], '']);
       assert.deepStrictEqual(inspect(parser('<small> a </small>')), [['<small> a </small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small>  a  </small>')), [['<small>  a  </small>'], '']);
       assert.deepStrictEqual(inspect(parser('<small>a</small>')), [['<small>a</small>'], '']);
       assert.deepStrictEqual(inspect(parser('<small>a</small>a')), [['<small>a</small>'], 'a']);
       assert.deepStrictEqual(inspect(parser('<small>a </small>')), [['<small>a </small>'], '']);
-      assert.deepStrictEqual(inspect(parser('<small>a  </small>')), [['<small>a  </small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small>a \n </small>')), [['<small>a </small>'], '']);
       assert.deepStrictEqual(inspect(parser('<small>a\n</small>')), [['<small>a</small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small>a\n </small>')), [['<small>a </small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small>a\n<wbr></small>')), [['<small>a<wbr></small>'], '']);
       assert.deepStrictEqual(inspect(parser('<small>a\nb</small>')), [['<small>a<br>b</small>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>a')), [['<wbr>'], 'a']);
     });
@@ -85,22 +88,27 @@ describe('Unit: parser/inline/html', () => {
     });
 
     it('attribute', () => {
-      assert.deepStrictEqual(inspect(parser('<small constructor>a</small>z')), [['<span class="invalid">&lt;small constructor&gt;a&lt;/small&gt;</span>'], 'z']);
-      assert.deepStrictEqual(inspect(parser('<small toString>a</small>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo>a</bdo>z')), [['<span class="invalid">&lt;bdo&gt;a&lt;/bdo&gt;</span>'], 'z']);
-      assert.deepStrictEqual(inspect(parser('<bdo >a</bdo>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo __proto__>a</bdo>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo constructor>a</bdo>z')), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], 'z']);
-      assert.deepStrictEqual(inspect(parser('<bdo toString>a</bdo>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo dir>a</bdo>z')), [['<span class="invalid">&lt;bdo dir&gt;a&lt;/bdo&gt;</span>'], 'z']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=>a</bdo>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=rtl>a</bdo>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=">a</bdo>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="">a</bdo>z')), [['<span class="invalid">&lt;bdo dir=""&gt;a&lt;/bdo&gt;</span>'], 'z']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" dir="rtl">a</bdo>z')), [['<span class="invalid">&lt;bdo dir="rtl" dir="rtl"&gt;a&lt;/bdo&gt;</span>'], 'z']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl">a</bdo>z')), [['<bdo dir="rtl">a</bdo>'], 'z']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" >a</bdo>z')), undefined);
-      assert.deepStrictEqual(inspect(parser('<wbr constructor>z')), [['<wbr class="invalid">'], 'z']);
+      assert.deepStrictEqual(inspect(parser('<small >a</small>')), [['<small>a</small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small  >a</small>')), [['<small>a</small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small __proto__>a</small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small constructor>a</small>')), [['<span class="invalid">&lt;small constructor&gt;a&lt;/small&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small toString>a</small>')), undefined);
+      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 constructor>a</bdo>')), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdo toString>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=>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" 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>')), [['<bdo dir="rtl">a</bdo>'], '']);
+      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('<bdo  dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr constructor>')), [['<wbr class="invalid">'], '']);
     });
 
   });

package/src/parser/inline/html.ts

@@ -2,10 +2,10 @@ import { undefined } from 'spica/global';
 import { isFrozen, ObjectEntries, ObjectFreeze, ObjectSetPrototypeOf, ObjectValues } from 'spica/alias';
 import { MarkdownParser } from '../../../markdown';
 import { HTMLParser } from '../inline';
-import { union, some, validate, context, creator, surround, match, lazy } from '../../combinator';
+import { union, some, validate, context, creator, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startLoose, trimNodeEndBR } from '../util';
+import { startLoose, blank } from '../util';
 import { html as h, defrag } from 'typed-dom';
 import { memoize } from 'spica/memoize';
 import { Cache } from 'spica/cache';
@@ -26,17 +26,17 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
     memoize(
     ([, tag]) =>
       surround(
-        `<${tag}`, some(union([attribute])), '>', true,
+        `<${tag}`, some(union([attribute])), /^\s*>/, true,
         ([, bs = []], rest) =>
           [[h(tag as 'span', attributes('html', [], attrspec[tag], bs))], rest]),
     ([, tag]) => tag)),
   match(
-    /^(?=<(sup|sub|small|bdo|bdi)(?=[^\S\n]|>))/,
+    /^(?=<(sup|sub|small)(?=[^\S\n]|>))/,
     memoize(
     ([, tag]) =>
       validate(`<${tag}`, `</${tag}>`,
       surround<HTMLParser.TagParser, string>(surround(
-        str(`<${tag}`), some(attribute), str('>'), true),
+        str(`<${tag}`), some(attribute), str(/^\s*>/), true),
         startLoose(
         context((() => {
           switch (tag) {
@@ -58,25 +58,49 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
                 }},
               };
             default:
+              assert(false);
               return {};
           }
         })(),
-        some(union([inline]), `</${tag}>`)), `</${tag}>`),
+        some(union([
+          some(inline, blank(/\n?/, `</${tag}>`)),
+          open(/^\n?/, some(inline, '</'), true),
+        ]), `</${tag}>`)), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest, context) =>
-          [[elem(tag, as, trimNodeEndBR(defrag(bs)), cs, context)], rest])),
+          [[elem(tag, as, defrag(bs), cs, context)], rest])),
       ([, tag]) => tag)),
+  match(
+    /^(?=<(bdo|bdi)(?=[^\S\n]|>))/,
+    memoize(
+    ([, tag]) =>
+      validate(`<${tag}`, `</${tag}>`,
+      surround<HTMLParser.TagParser, string>(surround(
+        str(`<${tag}`), some(attribute), str(/^\s*>/), true),
+        startLoose(some(union([
+          some(inline, blank(/\n?/, `</${tag}>`)),
+          open(/^\n?/, some(inline, '</'), true),
+        ]), `</${tag}>`), `</${tag}>`),
+        str(`</${tag}>`), false,
+        ([as, bs, cs], rest) =>
+          [[elem(tag, as, defrag(bs), cs, {})], rest],
+        ([as, bs], rest) =>
+          as.length === 1 ? [unshift(as, bs), rest] : undefined)),
+    ([, tag]) => tag)),
   match(
     /^(?=<([a-z]+)(?=[^\S\n]|>))/,
     memoize(
     ([, tag]) =>
       validate(`<${tag}`, `</${tag}>`,
       surround<HTMLParser.TagParser, string>(surround(
-        str(`<${tag}`), some(attribute), str('>'), true),
-        startLoose(some(union([inline]), `</${tag}>`), `</${tag}>`),
+        str(`<${tag}`), some(attribute), str(/^\s*>/), true),
+        startLoose(some(union([
+          some(inline, blank(/\n?/, `</${tag}>`)),
+          open(/^\n?/, some(inline, '</'), true),
+        ]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest) =>
-          [[elem(tag, as, trimNodeEndBR(defrag(bs)), cs, {})], rest],
+          [[elem(tag, as, defrag(bs), cs, {})], rest],
         ([as, bs], rest) =>
           as.length === 1 ? [unshift(as, bs), rest] : undefined)),
     ([, tag]) => tag,
@@ -87,8 +111,11 @@ export const attribute: HTMLParser.TagParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/),
 ]);
 
-function elem(tag: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[], context: MarkdownParser.Context): HTMLElement {
+function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: string[], context: MarkdownParser.Context): HTMLElement {
+  assert(as.length > 0);
+  assert(as[0][0] === '<' && as[as.length - 1].slice(-1) === '>');
   assert(bs.length === defrag(bs).length);
+  assert(cs.length === 1);
   if (!tags.includes(tag)) return invalid('tag', `Invalid HTML tag <${tag}>.`, as, bs, cs);
   switch (tag) {
     case 'sup':
@@ -108,11 +135,8 @@ function elem(tag: string, as: (HTMLElement | string)[], bs: (HTMLElement | stri
   }
   let attrs: Record<string, string | undefined> | undefined;
   switch (true) {
-    case as[as.length - 1] !== '>'
-      || 'data-invalid-syntax' in (attrs = attributes('html', [], attrspec[tag], as.slice(1, -1) as string[])):
+    case 'data-invalid-syntax' in (attrs = attributes('html', [], attrspec[tag], as.slice(1, -1) as string[])):
       return invalid('attribute', 'Invalid HTML attribute.', as, bs, cs);
-    case cs.length === 0:
-      return invalid('closer', `Missing the closing HTML tag <${tag}>.`, as, bs, cs);
     default:
       assert(attrs);
       return h(tag as 'span', attrs, bs);

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

@@ -18,7 +18,6 @@ describe('Unit: parser/inline/insertion', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('++a++')), [['<ins>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a+b++')), [['<ins>a+b</ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++a ++')), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++ ++')), [['<ins> </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++ a++')), [['<ins> a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++ a ++')), [['<ins> a </ins>'], '']);
@@ -26,7 +25,11 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('++\na++')), [['<ins><br>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\\\na++')), [['<ins><span class="linebreak"> </span>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++<wbr>a++')), [['<ins><wbr>a</ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a ++')), [['<ins>a </ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a \n ++')), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\n++')), [['<ins>a</ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a\n ++')), [['<ins>a </ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a\n<wbr>++')), [['<ins>a<wbr></ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\nb++')), [['<ins>a<br>b</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\\\nb++')), [['<ins>a<span class="linebreak"> </span>b</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\\+++')), [['<ins>+</ins>'], '']);

package/src/parser/inline/insertion.ts

@@ -1,14 +1,17 @@
 import { InsertionParser } from '../inline';
-import { union, some, creator, surround, lazy } from '../../combinator';
+import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { trimNodeEndBR } from '../util';
+import { blank } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
 export const insertion: InsertionParser = lazy(() => creator(surround(
   str('++'),
-  union([some(inline, '++')]),
+  some(union([
+    some(inline, blank(/\n?/, /\+\+/)),
+    open(/^\n?/, some(inline, '+'), true),
+  ])),
   str('++'), false,
-  ([, bs], rest) => [[html('ins', defrag(trimNodeEndBR(bs)))], rest],
+  ([, bs], rest) => [[html('ins', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

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

@@ -93,6 +93,9 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{b  }')), [['<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{ b }')), [['<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{ b  }')), [['<a href="b">b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{  b }')), [['<a href="b">b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{  b  }')), [['<a href="b">b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{  b   }')), [['<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\}')), [[`<a href="\\">\\</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\ }')), [[`<a href="\\">\\</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\b}')), [[`<a href="\\b">\\b</a>`], '']);

package/src/parser/inline/link.ts

@@ -7,7 +7,7 @@ import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { autolink } from '../autolink';
 import { str } from '../source';
-import { startLoose, trimNode, stringify } from '../util';
+import { startLoose, trimSpaceStart, trimNodeEnd, stringify } from '../util';
 import { html, define, defrag } from 'typed-dom';
 import { ReadonlyURL } from 'spica/url';
 
@@ -16,8 +16,7 @@ const optspec = {
 } as const;
 ObjectSetPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => creator(10, bind(
-  validate(['[', '{'], '}', '\n',
+export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}', '\n', bind(
   guard(context => context.syntax?.inline?.link ?? true,
   reverse(tails([
     context({ syntax: { inline: {
@@ -39,12 +38,12 @@ export const link: LinkParser = lazy(() => creator(10, bind(
           media: false,
           autolink: false,
         }}},
-        some(inline, ']', /^\\?\n/)), ']'),
+        trimSpaceStart(some(inline, ']', /^\\?\n/)))),
         ']',
         true),
     ]))),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]?}/)),
-  ])))),
+    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+  ]))),
   ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
     assert(params.every(p => typeof p === 'string'));
     if (eval(some(autolink)(stringify(content), context))?.some(node => typeof node === 'object')) return;
@@ -54,7 +53,7 @@ export const link: LinkParser = lazy(() => creator(10, bind(
     assert(!INSECURE_URI.match(/\s/));
     const el = elem(
       INSECURE_URI,
-      trimNode(defrag(content)),
+      trimNodeEnd(defrag(content)),
       new ReadonlyURL(
         resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
         context.host?.href || location.href),
@@ -62,18 +61,17 @@ export const link: LinkParser = lazy(() => creator(10, bind(
     if (el.classList.contains('invalid')) return [[el], rest];
     assert(el.classList.length === 0);
     return [[define(el, attributes('link', [], optspec, params))], rest];
-  })));
+  }))));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
-  open(/^[^\S\n]/, str(/^\S+/)),
+  open(/^[^\S\n]+/, str(/^\S+/)),
   str(/^[^\s{}]+/),
 ]);
 
 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]+(?=})/), () => []),
-  fmap(str(/^[^\S\n]+[^\n{}]+/), opt => [` \\${opt.slice(1)}`]),
+  fmap(str(/^[^\S\n]+[^\s{}]+/), opt => [` \\${opt.slice(1)}`]),
 ]);
 
 export function resolve(uri: string, host: URL | Location, source: URL | Location): string {

package/src/parser/inline/mark.ts

@@ -2,19 +2,16 @@ import { MarkParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isEndTightNodes, delimiter } from '../util';
+import { startTight, blank } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
 export const mark: MarkParser = lazy(() => creator(surround(
   str('=='),
   startTight(some(union([
-    some(inline, delimiter('==')),
+    some(inline, blank('', /==/)),
     open(some(inline, '='), inline),
   ]))),
   str('=='), false,
-  ([as, bs, cs], rest) =>
-    isEndTightNodes(bs)
-      ? [[html('mark', defrag(bs))], rest]
-      : [unshift(as, bs), cs[0] + rest],
+  ([, bs], rest) => [[html('mark', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

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

@@ -67,6 +67,9 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]{b  }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{ b }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{ b  }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{  b }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{  b  }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{  b   }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\}')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\ }')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\b}')), [['<a href="\\b" target="_blank"><img class="media" data-src="\\b" alt=""></a>'], '']);

package/src/parser/inline/media.ts

@@ -18,14 +18,17 @@ const optspec = {
 } as const;
 ObjectSetPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => creator(10, bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'], '}', '\n', bind(verify(fmap(open(
   '!',
-  validate(['[', '{'], '}', '\n',
   guard(context => context.syntax?.inline?.media ?? true,
   tails([
-    dup(surround(/^\[(?!\s*\\\s)/, some(union([unsafehtmlentity, bracket, txt]), ']', /^\\?\n/), ']', true)),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]?}/)),
-  ])))),
+    dup(surround(
+      /^\[(?!\s*\\\s)/,
+      some(union([unsafehtmlentity, bracket, txt]), ']', /^\\?\n/),
+      ']',
+      true)),
+    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+  ]))),
   ([as, bs]) => bs ? [[join(as).trim() || join(as)], bs] : [[''], as]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
@@ -51,7 +54,7 @@ export const media: MediaParser = lazy(() => creator(10, bind(verify(fmap(open(
       link as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${join(params)} }${rest}`, context);
-  })));
+  }))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),

package/src/parser/inline/reference.ts

@@ -3,7 +3,7 @@ import { ReferenceParser } from '../inline';
 import { union, subsequence, some, validate, verify, focus, guard, context, creator, surround, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startLoose, isStartLoose, trimNode, stringify } from '../util';
+import { startLoose, isStartLoose, trimSpaceStart, trimNodeEnd, stringify } from '../util';
 import { html, defrag } from 'typed-dom';
 
 export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]', '\n', fmap(surround(
@@ -22,16 +22,16 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
   }}, state: undefined },
   subsequence([
     abbr,
-    focus('^', c => [['', c], '']),
-    some(inline, ']', /^\\?\n/),
-  ])), ']]')),
+    focus(/^\^[^\S\n]*/, source => [['', source], '']),
+    trimSpaceStart(some(inline, ']', /^\\?\n/)),
+  ])))),
   ']]'),
-  ns => [html('sup', attributes(ns), trimNode(defrag(ns)))]))));
+  ns => [html('sup', attributes(ns), trimNodeEnd(defrag(ns)))]))));
 
 const abbr: ReferenceParser.AbbrParser = creator(fmap(verify(surround(
   '^',
   union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
-  /^\|?(?=]])|^\|[^\S\n]/),
+  /^\|?(?=]])|^\|[^\S\n]+/),
   (_, rest, context) => isStartLoose(rest, context)),
   ([source]) => [html('abbr', source)]));
 

package/src/parser/inline/ruby.ts

@@ -8,12 +8,11 @@ import { isStartTightNodes } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift, push, join } from 'spica/array';
 
-export const ruby: RubyParser = lazy(() => creator(bind(verify(
-  validate('[', ')', '\n',
+export const ruby: RubyParser = lazy(() => creator(validate('[', ')', '\n', bind(verify(
   sequence([
     surround('[', focus(/^(?:\\[^\n]|[^\\\[\]\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\\\(\)\n])+(?=\))/, text), ')'),
-  ])),
+  ]),
   ([texts]) => isStartTightNodes(texts)),
   ([texts, rubies], rest) => {
     const tail = typeof texts[texts.length - 1] === 'object'
@@ -44,7 +43,7 @@ export const ruby: RubyParser = lazy(() => creator(bind(verify(
           [html('rp', '('), html('rt', join(rubies, ' ').trim()), html('rp', ')')]), tail)))
         ], rest];
     }
-  })));
+  }))));
 
 const text: RubyParser.TextParser = creator((source, context) => {
   const acc = [''];

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

@@ -9,11 +9,11 @@ describe('Unit: parser/inline/strong', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('**')), undefined);
       assert.deepStrictEqual(inspect(parser('**a')), [['**', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*')), [['**', 'a', '*'], '']);
       assert.deepStrictEqual(inspect(parser('**a **')), [['**', 'a', ' ', '**'], '']);
       assert.deepStrictEqual(inspect(parser('**a\n**')), [['**', 'a', '<br>', '**'], '']);
       assert.deepStrictEqual(inspect(parser('**a\\ **')), [['**', 'a', ' ', '**'], '']);
       assert.deepStrictEqual(inspect(parser('**a\\\n**')), [['**', 'a', '<span class="linebreak"> </span>', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*')), [['**', 'a', '*'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('** **')), undefined);
       assert.deepStrictEqual(inspect(parser('** a**')), undefined);

package/src/parser/inline/strong.ts

@@ -2,19 +2,16 @@ import { StrongParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isEndTightNodes, delimiter } from '../util';
+import { startTight, blank } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
 export const strong: StrongParser = lazy(() => creator(surround(
   str('**'),
   startTight(some(union([
-    some(inline, delimiter(String.raw`\*\*`)),
+    some(inline, blank('', /\*\*/)),
     open(some(inline, '*'), inline),
   ])), '*'),
   str('**'), false,
-  ([as, bs, cs], rest) =>
-    isEndTightNodes(bs)
-      ? [[html('strong', defrag(bs))], rest]
-      : [unshift(as, bs), cs[0] + rest],
+  ([, bs], rest) => [[html('strong', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline.test.ts

@@ -92,7 +92,6 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('***a***')), [['<em><strong>a</strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a***b')), [['<em><strong>a</strong></em>', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('***a****')), [['<em><strong>a</strong></em>', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('***a *b****')), [['<em><strong>a <em>b</em></strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('****a***')), [['****', 'a', '***'], '']);
       assert.deepStrictEqual(inspect(parser('****a****')), [['****', 'a', '****'], '']);
       assert.deepStrictEqual(inspect(parser('*(*a*)*')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
@@ -118,9 +117,9 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[[#a]]')), [['<sup class="reference"><a href="/hashtags/a" class="hashtag">#a</a></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[$-1]]')), [['<sup class="reference"><a class="label" data-label="$-1">$-1</a></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[#-1]]{b}')), [['<sup class="reference">#-1</sup>', '<a href="b">b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[#-1]](b)')), [['<sup class="reference">#-1</sup>', '(b)'], '']);
+      assert.deepStrictEqual(inspect(parser('[[#-1]](b)')), [['<sup class="reference">#-1</sup>', '(', 'b', ')'], '']);
       assert.deepStrictEqual(inspect(parser('[[#-1]a]{b}')), [['<a href="b">[#-1]a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[#-1]a](b)')), [['[', '<a class="index" href="#index:-1">-1</a>', 'a', ']', '(b)'], '']);
+      assert.deepStrictEqual(inspect(parser('[[#-1]a](b)')), [['[', '<a class="index" href="#index:-1">-1</a>', 'a', ']', '(', 'b', ')'], '']);
       assert.deepStrictEqual(inspect(parser('[#a]{b}')), [['<a class="index" href="#index:a">a</a>', '<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]{b}')), [['[', '<a href="/@a" class="account">@a</a>', ']', '<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[http://host]{http://evil}')), [['[', '<a href="http://host" target="_blank">http://host</a>', ']', '<a href="http://evil" target="_blank">http://evil</a>'], '']);