securemark 0.235.1 → 0.236.0

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,
@@ -89,41 +113,41 @@ export const attribute: HTMLParser.TagParser.AttributeParser = union([
 
 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);
+  if (!tags.includes(tag)) return invalid('tag', `Invalid HTML tag <${tag}>`, as, bs, cs);
   switch (tag) {
     case 'sup':
     case 'sub':
       switch (true) {
         case context.state?.in?.supsub:
-          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup> or <sub> HTML tag.`, as, bs, cs);
+          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup> or <sub> HTML tag`, as, bs, cs);
       }
       break;
     case 'small':
       switch (true) {
         case context.state?.in?.supsub:
         case context.state?.in?.small:
-          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup>, <sub>, or <small> HTML tag.`, as, bs, cs);
+          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup>, <sub>, or <small> HTML tag`, as, bs, cs);
       }
       break;
   }
   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[])):
-      return invalid('attribute', 'Invalid HTML attribute.', as, bs, cs);
+    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);
     default:
       assert(attrs);
       return h(tag as 'span', attrs, bs);
   }
 }
-function invalid(type: string, description: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
+function invalid(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
   return h('span', {
     class: 'invalid',
     'data-invalid-syntax': 'html',
     'data-invalid-type': type,
-    'data-invalid-description': description,
+    'data-invalid-message': message,
   }, defrag(push(unshift(as, bs), cs)));
 }
 
@@ -163,7 +187,7 @@ export function attributes(
     attrs['class'] = join(classes, ' ');
     attrs['data-invalid-syntax'] = syntax;
     attrs['data-invalid-type'] = 'argument';
-    attrs['data-invalid-description'] = 'Invalid argument.';
+    attrs['data-invalid-message'] = 'Invalid argument';
   }
   return attrs;
 }

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

@@ -14,7 +14,6 @@ describe('Unit: parser/inline/htmlentity', () => {
       assert.deepStrictEqual(inspect(parser('& ;')), undefined);
       assert.deepStrictEqual(inspect(parser('&\n;')), undefined);
       assert.deepStrictEqual(inspect(parser('&a;')), [['<span class="invalid">&amp;a;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('&NewLine;')), undefined);
       assert.deepStrictEqual(inspect(parser('&#;')), undefined);
       assert.deepStrictEqual(inspect(parser('&#g;')), undefined);
       assert.deepStrictEqual(inspect(parser('&#x;')), undefined);
@@ -36,6 +35,7 @@ describe('Unit: parser/inline/htmlentity', () => {
     });
 
     it('entity', () => {
+      assert.deepStrictEqual(inspect(parser('&NewLine;')), [[' '], '']);
       assert.deepStrictEqual(inspect(parser('&nbsp;')), [['\u00A0'], '']);
       assert.deepStrictEqual(inspect(parser('&amp;')), [['&'], '']);
       assert.deepStrictEqual(inspect(parser('&copy;')), [['©'], '']);

package/src/parser/inline/htmlentity.ts

@@ -1,24 +1,31 @@
+import { undefined } from 'spica/global';
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { union, validate, focus, creator, fmap } from '../../combinator';
 import { html } from 'typed-dom';
+import { reduce } from 'spica/memoize';
 
 export const unsafehtmlentity: UnsafeHTMLEntityParser = creator(validate('&', focus(
-  /^&(?!NewLine;)[0-9A-Za-z]+;/,
-  (parser => entity => (
-    parser.innerHTML = entity,
-    entity = parser.textContent!,
-    [[`${entity[0] !== '&' || entity.length === 1 ? '' : '\0'}${entity}`], '']
-  ))(html('b')))));
+  /^&[0-9A-Za-z]+;/,
+  entity => [[parse(entity) ?? `\0${entity}`], ''])));
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
-  ([str]) => [
-    str[0] === '\0'
+  ([test]) => [
+    test[0] === '\0'
       ? html('span', {
           class: 'invalid',
           'data-invalid-syntax': 'htmlentity',
           'data-invalid-type': 'syntax',
-          'data-invalid-description': 'Invalid HTML entity.',
-        }, str.slice(1))
-      : str,
+          'data-invalid-message': 'Invalid HTML entity',
+        }, test.slice(1))
+      : test,
   ]);
+
+const parse = reduce((el => (entity: string): string | undefined => {
+  if (entity === '
') return ' ';
+  el.innerHTML = entity;
+  const text = el.textContent!;
+  return entity === text
+    ? undefined
+    : text;
+})(html('b')));

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';
 
@@ -38,11 +38,11 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
           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'));
@@ -53,7 +53,7 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
     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),
@@ -64,15 +64,14 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
   }))));
 
 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 {
@@ -104,7 +103,7 @@ function elem(
   origin: string,
 ): HTMLAnchorElement {
   let type: string;
-  let description: string;
+  let message: string;
   switch (uri.protocol) {
     case 'http:':
     case 'https:':
@@ -112,7 +111,7 @@ function elem(
       if (INSECURE_URI.slice(0, 2) === '^/' &&
           /\/\.\.?(?:\/|$)/.test(INSECURE_URI.slice(0, INSECURE_URI.search(/[?#]|$/)))) {
         type = 'argument';
-        description = 'Dot-segments cannot be used in subresource paths.';
+        message = 'Dot-segments cannot be used in subresource paths';
         break;
       }
       return html('a',
@@ -141,7 +140,7 @@ function elem(
           return html('a', { href: uri.source }, content);
       }
       type = 'content';
-      description = 'Invalid phone number.';
+      message = 'Invalid phone number';
       break;
   }
   return html('a',
@@ -149,7 +148,7 @@ function elem(
       class: 'invalid',
       'data-invalid-syntax': 'link',
       'data-invalid-type': type ??= 'argument',
-      'data-invalid-description': description ??= 'Invalid protocol.',
+      'data-invalid-message': message ??= 'Invalid protocol',
     },
     content.length === 0
       ? INSECURE_URI

package/src/parser/inline/mark.ts

@@ -2,14 +2,14 @@ import { MarkParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, 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,

package/src/parser/inline/math.ts

@@ -29,7 +29,7 @@ export const math: MathParser = lazy(() => creator(validate('$', rewrite(
             translate: 'no',
             'data-invalid-syntax': 'math',
             'data-invalid-type': 'content',
-            'data-invalid-description': `"${source.match(disallowedCommand)![0]}" command is disallowed.`,
+            'data-invalid-message': `"${source.match(disallowedCommand)![0]}" command is disallowed`,
           },
       source)
   ], '']))));

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

@@ -27,7 +27,7 @@ export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'],
       some(union([unsafehtmlentity, bracket, txt]), ']', /^\\?\n/),
       ']',
       true)),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]?}/)),
+    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ]))),
   ([as, bs]) => bs ? [[join(as).trim() || join(as)], bs] : [[''], as]),
   ([[text]]) => text === '' || text.trim() !== ''),
@@ -81,7 +81,7 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
           class: void target.classList.add('invalid'),
           'data-invalid-syntax': 'media',
           'data-invalid-type': 'argument',
-          'data-invalid-description': 'Dot-segments cannot be used in media paths; use subresource paths instead.',
+          'data-invalid-message': 'Dot-segments cannot be used in media paths; use subresource paths instead',
         });
         return false;
       }
@@ -91,7 +91,7 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
         class: void target.classList.add('invalid'),
         'data-invalid-syntax': 'media',
         'data-invalid-type': 'argument',
-        'data-invalid-description': 'Invalid protocol.',
+        'data-invalid-message': 'Invalid protocol',
       });
       return false;
   }
@@ -100,7 +100,7 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
       class: void target.classList.add('invalid'),
       'data-invalid-syntax': 'media',
       'data-invalid-type': 'content',
-      'data-invalid-description': `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}".`,
+      'data-invalid-message': `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`,
       alt: target.getAttribute('alt')?.replace(/\0/g, ''),
     });
     return false;

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)]));
 
@@ -46,7 +46,7 @@ function attributes(ns: (string | HTMLElement)[]): Record<string, string | undef
           class: 'invalid',
           'data-invalid-syntax': 'reference',
           'data-invalid-type': 'syntax',
-          'data-invalid-description': 'Invalid abbr.',
+          'data-invalid-message': 'Invalid abbr',
         }
       : { class: 'reference' };
 }

package/src/parser/inline/ruby.ts

@@ -83,13 +83,13 @@ function attributes(texts: string[], rubies: string[]): Record<string, string> {
   let attrs: Record<string, string> | undefined;
   for (const ss of [texts, rubies]) {
     for (let i = 0; i < ss.length; ++i) {
-      if (!ss[i].includes('\0')) continue;
+      if (ss[i].indexOf('\0') === -1) continue;
       ss[i] = ss[i].replace(/\0/g, '');
       attrs ??= {
         class: 'invalid',
         'data-invalid-syntax': 'ruby',
         'data-invalid-type': ss === texts ? 'content' : 'argument',
-        'data-invalid-description': 'Invalid HTML entity.',
+        'data-invalid-message': 'Invalid HTML entity',
       };
     }
   }

package/src/parser/inline/strong.ts

@@ -2,14 +2,14 @@ import { StrongParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, 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(/\*\*/)),
+    some(inline, blank('', '**')),
     open(some(inline, '*'), inline),
   ])), '*'),
   str('**'), false,

package/src/parser/inline.test.ts

@@ -117,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>'], '']);