securemark 0.234.1 → 0.235.0

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.ts

@@ -26,11 +26,9 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
     memoize(
     ([, tag]) =>
       surround(
-        str(`<${tag}`), some(union([attribute])), str('>'), true,
-        ([, as = []], rest) => [
-          [h(tag as 'span', attributes('html', [], attrspec[tag], as))],
-          rest
-        ]),
+        `<${tag}`, some(union([attribute])), '>', true,
+        ([, bs = []], rest) =>
+          [[h(tag as 'span', attributes('html', [], attrspec[tag], bs))], rest]),
     ([, tag]) => tag)),
   match(
     /^(?=<(sup|sub|small|bdo|bdi)(?=[^\S\n]|>))/,
@@ -80,9 +78,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
         ([as, bs, cs], rest) =>
           [[elem(tag, as, trimNodeEndBR(defrag(bs)), cs, {})], rest],
         ([as, bs], rest) =>
-          as.length === 1
-            ? [unshift(as, bs), rest]
-            : undefined)),
+          as.length === 1 ? [unshift(as, bs), rest] : undefined)),
     ([, tag]) => tag,
     new Cache(1000))),
 ])))));

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

@@ -14,6 +14,7 @@ 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);

package/src/parser/inline/htmlentity.ts

@@ -2,18 +2,15 @@ import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { union, validate, focus, creator, fmap } from '../../combinator';
 import { html } from 'typed-dom';
 
-const parser = html('textarea');
+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')))));
 
-export const unsafehtmlentity: UnsafeHTMLEntityParser = creator(validate('&', fmap(focus(
-  /^&[0-9A-Za-z]+;/,
-  entity => [[(parser.innerHTML = entity, parser.value)], '']),
-  ([str]) => [
-    str[0] !== '&' || str.length < 3
-      ? str
-      : `\0${str}`,
-  ])));
-
-export const htmlentity: HTMLEntityParser = creator(validate('&', fmap(
+export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
   ([str]) => [
     str[0] === '\0'
@@ -24,4 +21,4 @@ export const htmlentity: HTMLEntityParser = creator(validate('&', fmap(
           'data-invalid-description': 'Invalid HTML entity.',
         }, str.slice(1))
       : str,
-  ])));
+  ]);

package/src/parser/inline/link.ts

@@ -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: {
@@ -44,7 +43,7 @@ export const link: LinkParser = lazy(() => creator(10, bind(
         true),
     ]))),
     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;
@@ -62,7 +61,7 @@ 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+/)),

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

@@ -14,8 +14,8 @@ describe('Unit: parser/inline/mark', () => {
       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\\\n==')), [['==', 'a', '<span class="linebreak"> </span>', '=='], '']);
       assert.deepStrictEqual(inspect(parser('== ==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a ==')), undefined);
@@ -35,8 +35,11 @@ describe('Unit: parser/inline/mark', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('==*==a==*==')), [['<mark><em><mark>a</mark></em></mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==a ==b====')), [['<mark>a <mark>b</mark></mark>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\ ==b====')), [['<mark>a <mark>b</mark></mark>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark>a\t<mark>b</mark></mark>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a<wbr>==b====')), [['<mark>a<wbr><mark>b</mark></mark>'], '']);
+      assert.deepStrictEqual(inspect(parser('==*==a==*==')), [['<mark><em><mark>a</mark></em></mark>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -1,16 +1,16 @@
 import { MarkParser } from '../inline';
-import { union, sequence, some, creator, surround, lazy } from '../../combinator';
+import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isEndTightNodes } from '../util';
+import { startTight, isEndTightNodes, delimiter } 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, /^\s*==/),
-    sequence([some(inline, '='), inline]),
+    some(inline, delimiter(/==/)),
+    open(some(inline, '='), inline),
   ]))),
   str('=='), false,
   ([as, bs, cs], rest) =>

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(
+      /^\[(?!\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/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

@@ -12,8 +12,8 @@ describe('Unit: parser/inline/strong', () => {
       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\\\n**')), [['**', 'a', '<span class="linebreak"> </span>', '**'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('** **')), undefined);
       assert.deepStrictEqual(inspect(parser('** a**')), undefined);
@@ -35,10 +35,12 @@ describe('Unit: parser/inline/strong', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('**a*b*c**')), [['<strong>a<em>b</em>c</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b*c**d')), [['<strong>a<em>b</em>c</strong>'], 'd']);
       assert.deepStrictEqual(inspect(parser('**a *b***')), [['<strong>a <em>b</em></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a **b****')), [['<strong>a <strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a&Tab;**b****')), [['<strong>a\t<strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a<wbr>**b****')), [['<strong>a<wbr><strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c**')), [['<strong>a<em>b</em>c</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c**d')), [['<strong>a<em>b</em>c</strong>'], 'd']);
       assert.deepStrictEqual(inspect(parser('**`a`**')), [['<strong><code data-src="`a`">a</code></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**<small>**')), [['<strong>&lt;small&gt;</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**(*a*)**')), [['<strong><span class="paren">(<em>a</em>)</span></strong>'], '']);

package/src/parser/inline/strong.ts

@@ -1,17 +1,17 @@
 import { StrongParser } from '../inline';
-import { union, sequence, some, creator, surround, close, lazy } from '../../combinator';
+import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isEndTightNodes } from '../util';
+import { startTight, isEndTightNodes, delimiter } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
-export const strong: StrongParser = lazy(() => creator(surround(close(
-  str('**'), /^(?!\*)/),
+export const strong: StrongParser = lazy(() => creator(surround(
+  str('**'),
   startTight(some(union([
-    some(inline, /^\s*\*\*/),
-    sequence([some(inline, '*'), inline]),
-  ]))),
+    some(inline, delimiter(/\*\*/)),
+    open(some(inline, '*'), inline),
+  ])), '*'),
   str('**'), false,
   ([as, bs, cs], rest) =>
     isEndTightNodes(bs)

package/src/parser/inline.test.ts

@@ -64,18 +64,28 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('***a*b*c***')), [['<strong><em>a</em>b<em>c</em></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*c***d')), [['<strong><em>a</em>b<em>c</em></strong>', 'd'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b**c****')), [['<strong><em>a</em>b</strong>', 'c', '****'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b *c***')), [['<strong><em>a</em>b <em>c</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\\ *b**')), [['***', 'a', ' ', '<em>b</em>', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('***a* **b****')), [['<strong><em>a</em> <strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*\\ **b****')), [['<strong><em>a</em> <strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*&Tab;**b****')), [['<strong><em>a</em>\t<strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*<wbr>**b****')), [['<strong><em>a</em><wbr><strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a *b****')), [['<em><strong>a <em>b</em></strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a\\ *b****')), [['<em><strong>a <em>b</em></strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a&Tab;*b****')), [['<em><strong>a\t<em>b</em></strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a<wbr>*b****')), [['<em><strong>a<wbr><em>b</em></strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b **')), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b\\ **')), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
-      assert.deepStrictEqual(inspect(parser('***a* b**')), [['<strong><em>a</em> b</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*')), [['<em><strong>a</strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*c')), [['<em><strong>a</strong>b</em>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*c**')), [['<em><strong>a</strong>b</em>', 'c', '**'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c***')), [['<em><strong>a</strong>b<strong>c</strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c***d')), [['<em><strong>a</strong>b<strong>c</strong></em>', 'd'], '']);
-      assert.deepStrictEqual(inspect(parser('***a**b **c***')), [['<em><strong>a</strong>b <strong>c</strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a** b*')), [['<em><strong>a</strong> b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a** *b**')), [['<em><strong>a</strong> <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**\\ *b**')), [['<em><strong>a</strong> <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**&Tab;*b**')), [['<em><strong>a</strong>\t<em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**<wbr>*b**')), [['<em><strong>a</strong><wbr><em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a **b*')), [['***', 'a', ' ', '**', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser('***a\\ **b*')), [['***', 'a', ' ', '**', 'b', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b *')), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b\\ *')), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
       assert.deepStrictEqual(inspect(parser('***a*')), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**')), [['*', '<strong>a</strong>'], '']);

package/src/parser/util.ts

@@ -4,47 +4,16 @@ import { Parser, eval } from '../combinator/data/parser';
 import { union, some, verify, convert } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
 import { linebreak, unescsource } from './source';
+import { invisibleHTMLEntityNames } from './api/normalize';
 import { push, pop } from 'spica/array';
 
-// https://dev.w3.org/html5/html-author/charref
-const invisibleHTMLEntityNames = [
-  'Tab',
-  'NewLine',
-  'NonBreakingSpace',
-  'nbsp',
-  'shy',
-  'ensp',
-  'emsp',
-  'emsp13',
-  'emsp14',
-  'numsp',
-  'puncsp',
-  'ThinSpace',
-  'thinsp',
-  'VeryThinSpace',
-  'hairsp',
-  'ZeroWidthSpace',
-  'NegativeVeryThinSpace',
-  'NegativeThinSpace',
-  'NegativeMediumSpace',
-  'NegativeThickSpace',
-  'zwj',
-  'zwnj',
-  'lrm',
-  'rlm',
-  'MediumSpace',
-  'NoBreak',
-  'ApplyFunction',
-  'af',
-  'InvisibleTimes',
-  'it',
-  'InvisibleComma',
-  'ic',
-];
-const blankline = new RegExp(String.raw`^(?!$)(?:\\$|\\?[^\S\n]|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)+$`, 'gm');
+export function delimiter(opener: RegExp): RegExp {
+  return new RegExp(String.raw`^(?:\s+|\\\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)?${opener.source}`);
+}
 
 export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+  const blankline = new RegExp(String.raw`^(?:\\$|\\?[^\S\n]|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)+$`, 'gm');
   return union([
     convert(
       source => source.replace(blankline, line => line.replace(/[\\&<]/g, '\x1B$&')),
@@ -79,18 +48,18 @@ export function startLoose<T extends HTMLElement | string>(parser: Parser<T>, ex
 export function isStartLoose(source: string, context: MarkdownParser.Context, except?: string): boolean {
   source &&= source.replace(/^[^\S\n]+/, '');
   if (source === '') return true;
-  return source.slice(0, except?.length ?? 0) !== except
-      && isStartTight(source, context);
+  return isStartTight(source, context, except);
 }
-export function startTight<P extends Parser<unknown>>(parser: P): P;
-export function startTight<T>(parser: Parser<T>): Parser<T> {
+export function startTight<P extends Parser<unknown>>(parser: P, except?: string): P;
+export function startTight<T>(parser: Parser<T>, except?: string): Parser<T> {
   return (source, context) =>
-    isStartTight(source, context)
+    isStartTight(source, context, except)
       ? parser(source, context)
       : undefined;
 }
-function isStartTight(source: string, context: MarkdownParser.Context): boolean {
+function isStartTight(source: string, context: MarkdownParser.Context, except?: string): boolean {
   if (source === '') return true;
+  if (except && source.slice(0, except.length) === except) return false;
   switch (source[0]) {
     case ' ':
     case '　':