securemark 0.247.2 → 0.249.0

package/src/parser/inline/media.ts

@@ -7,7 +7,7 @@ import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, push, join } from 'spica/array';
+import { unshift, push } from 'spica/array';
 
 const optspec = {
   'width': [],
@@ -28,7 +28,7 @@ export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'],
       true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ]))),
-  ([as, bs]) => bs ? [[join(as).trim() || join(as)], bs] : [[''], as]),
+  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], bs] : [[''], as]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
     assert(text === text.trim());
@@ -52,7 +52,7 @@ export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'],
     return fmap(
       link as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
-      (`{ ${INSECURE_URI}${join(params)} }${rest}`, context);
+      (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
   }))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => union([

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

@@ -16,9 +16,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[ ]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\na]]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[\\ a]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\\\na]]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[<wbr>a]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[a\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[a\\\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[a\nb]]')), undefined);
@@ -33,6 +31,8 @@ describe('Unit: parser/inline/reference', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('[[ a]]')), [['<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[ a ]]')), [['<sup class="reference">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[\\ a]]')), [['<sup class="reference">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[<wbr>a]]')), [['<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a]]')), [['<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a ]]')), [['<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a  ]]')), [['<sup class="reference">a</sup>'], '']);
@@ -68,8 +68,8 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[^a|b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a|b ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a|b  ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a|<wbr>]]')), [['<sup class="invalid">^a|</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a|<wbr>b]]')), [['<sup class="invalid">^a|<wbr>b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|<wbr>]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|<wbr>b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a|^b]]')), [['<sup class="reference" data-abbr="a">^b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a| ]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a| b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
@@ -87,7 +87,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser(`[[^A's, Aces']]`)), [[`<sup class="reference" data-abbr="A's, Aces'"></sup>`], '']);
       assert.deepStrictEqual(inspect(parser('[[^^]]')), [['<sup class="invalid">^^</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[\\^]]')), [['<sup class="reference">^</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^ ]]')), [['<sup class="invalid">^</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ ]]')), [['<sup class="invalid">^ </sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^ a]]')), [['<sup class="invalid">^ a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^ |]]')), [['<sup class="invalid">^ |</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^ |b]]')), [['<sup class="invalid">^ |b</sup>'], '']);

package/src/parser/inline/reference.ts

@@ -1,15 +1,14 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, validate, verify, focus, guard, context, creator, surround, lazy, fmap } from '../../combinator';
+import { union, subsequence, some, validate, focus, guard, context, creator, surround, lazy, fmap, bind } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startLoose, isStartLoose, trimSpaceStart, trimNodeEnd, stringify } from '../util';
+import { regBlankInlineStart, trimBlankInline, stringify } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]', '\n', fmap(surround(
   '[[',
   guard(context => context.syntax?.inline?.reference ?? true,
-  startLoose(
   context({ syntax: { inline: {
     annotation: false,
     reference: false,
@@ -19,21 +18,20 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
     //label: true,
     //link: true,
     //autolink: true,
-  }}, state: undefined, delimiters: undefined },
+  }}, delimiters: undefined },
   subsequence([
     abbr,
     focus(/^\^[^\S\n]*/, source => [['', source], '']),
-    trimSpaceStart(some(inline, ']', /^\\?\n/)),
-  ])))),
+    trimBlankInline(some(inline, ']', /^\\?\n/)),
+  ]))),
   ']]'),
-  ns => [html('sup', attributes(ns), trimNodeEnd(defrag(ns)))]))));
+  ns => [html('sup', attributes(ns), defrag(ns))]))));
 
-const abbr: ReferenceParser.AbbrParser = creator(fmap(verify(surround(
+const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
   '^',
   union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
   /^\|?(?=]])|^\|[^\S\n]*/),
-  (_, rest, context) => isStartLoose(rest, context)),
-  ([source]) => [html('abbr', source)]));
+  ([source], rest) => [[html('abbr', source)], rest.replace(regBlankInlineStart, '')]));
 
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
   return typeof ns[0] === 'object' && ns[0].tagName === 'ABBR'

package/src/parser/inline/ruby.ts

@@ -6,7 +6,7 @@ import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
 import { isStartTightNodes } from '../util';
 import { html, defrag } from 'typed-dom/dom';
-import { unshift, push, join } from 'spica/array';
+import { unshift, push } from 'spica/array';
 
 export const ruby: RubyParser = lazy(() => creator(validate('[', ')', '\n', bind(verify(
   sequence([
@@ -39,8 +39,8 @@ export const ruby: RubyParser = lazy(() => creator(validate('[', ')', '\n', bind
       default:
         assert(rubies.length > 0);
         return [[html('ruby', attributes(texts, rubies), defrag(push(unshift(
-          [join(texts, ' ')],
-          [html('rp', '('), html('rt', join(rubies, ' ').trim()), html('rp', ')')]), tail)))
+          [texts.join(' ')],
+          [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]), tail)))
         ], rest];
     }
   }))));
@@ -74,7 +74,7 @@ const text: RubyParser.TextParser = creator((source, context) => {
       }
     }
   }
-  return join(acc).trimStart()
+  return acc.join('').trimStart()
     ? [[acc], '']
     : undefined;
 });

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

@@ -9,10 +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\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  **')), [['**', 'a', ' '], ' **']);
+      assert.deepStrictEqual(inspect(parser('**a\n**')), [['**', 'a'], '\n**']);
+      assert.deepStrictEqual(inspect(parser('**a\\ **')), [['**', 'a'], '\\ **']);
+      assert.deepStrictEqual(inspect(parser('**a\\\n**')), [['**', 'a'], '\\\n**']);
       assert.deepStrictEqual(inspect(parser('**a*')), [['**', 'a', '*'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('** **')), undefined);

package/src/parser/inline/strong.ts

@@ -1,16 +1,20 @@
 import { StrongParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
+import { emstrong } from './emstrong';
 import { str } from '../source';
-import { startTight, blank } from '../util';
+import { startTight, blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const strong: StrongParser = lazy(() => creator(surround(
   str('**'),
   startTight(some(union([
-    some(inline, blank('', '**')),
-    open(some(inline, '*'), inline),
+    some(inline, blankWith('**')),
+    open(some(inline, '*'), union([
+      emstrong,
+      strong,
+    ])),
   ])), '*'),
   str('**'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],

package/src/parser/inline.test.ts

@@ -157,6 +157,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a href="http://host" target="_blank">http://host</a>', '>'], '']);
       assert.deepStrictEqual(inspect(parser('<<small>a<</small>')), [['<', '<small>a&lt;</small>'], '']);
       assert.deepStrictEqual(inspect(parser('<sup><sub>a</sub>')), [['<', 'sup', '>', '<sub>a</sub>'], '']);
+      assert.deepStrictEqual(inspect(parser('*<small>*`</small>`')), [['<em>&lt;small&gt;</em>', '<code data-src="`</small>`">&lt;/small&gt;</code>'], '']);
       assert.deepStrictEqual(inspect(parser('[~http://host')), [['[', '~', '<a href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[~a@b')), [['[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[~~a~~]')), [['[', '<del>a</del>', ']'], '']);

package/src/parser/processor/figure.ts

@@ -2,7 +2,7 @@ import { Infinity, Set, Map } from 'spica/global';
 import { number as calculate, isFixed } from '../inline/extension/label';
 import { define } from 'typed-dom/dom';
 import { MultiMap } from 'spica/multimap';
-import { push, join } from 'spica/array';
+import { push } from 'spica/array';
 
 export function* figure(
   target: ParentNode & Node,
@@ -85,7 +85,7 @@ export function* figure(
     let number = calculate(
       label,
       numbers.has(group) && !isFixed(label)
-        ? join(numbers.get(group)!.split('.').slice(0, bases.length), '.')
+        ? numbers.get(group)!.split('.').slice(0, bases.length).join('.')
         : base);
     assert(def.matches('figure') || number.endsWith('.0'));
     if (number.endsWith('.0')) {
@@ -94,19 +94,18 @@ export function* figure(
       if (group !== '$' || tagName === 'FIGURE' && def.firstChild) continue;
       if (number.startsWith('0.')) {
         assert(number.endsWith('.0'));
-        number = join(
-          index.slice(0)
-            .reduce((ns, _, i, xs) => {
-              i === ns.length
-                ? xs.length = i
-                : ns[i] = +ns[i] > +xs[i]
-                  ? ns[i]
-                  : +ns[i] === 0
-                    ? xs[i]
-                    : `${+xs[i] + 1}`;
-              return ns;
-            }, number.split('.')),
-          '.');
+        number = index.slice(0)
+          .reduce((ns, _, i, xs) => {
+            i === ns.length
+              ? xs.length = i
+              : ns[i] = +ns[i] > +xs[i]
+                ? ns[i]
+                : +ns[i] === 0
+                  ? xs[i]
+                  : `${+xs[i] + 1}`;
+            return ns;
+          }, number.split('.'))
+          .join('.');
       }
       base = number;
       bases = index = base.split('.');
@@ -184,8 +183,8 @@ function increment(bases: readonly string[], el: HTMLHeadingElement): string {
   const index = (+el.tagName[1] - 1 || 1) - 1;
   assert(index >= 0);
   return index + 1 < bases.length
-    ? join(
-        bases.slice(0, index + 2).map((v, i) => {
+    ? bases.slice(0, index + 2)
+        .map((v, i) => {
           switch (true) {
             case i < index:
               return v;
@@ -194,8 +193,8 @@ function increment(bases: readonly string[], el: HTMLHeadingElement): string {
             default:
               return 0;
           }
-        }),
-        '.')
+        })
+        .join('.')
     : '';
 }
 

package/src/parser/source/escapable.test.ts

@@ -18,10 +18,11 @@ describe('Unit: parser/source/escsource', () => {
 
     it('space', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  ')), [['  '], '']);
-      assert.deepStrictEqual(inspect(parser('   ')), [['   '], '']);
+      assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
       assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n')), [['  ', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
     });
 
     it('linebreak', () => {

package/src/parser/source/escapable.ts

@@ -2,11 +2,11 @@ import { EscapableSourceParser } from '../source';
 import { creator } from '../../combinator';
 import { nonWhitespace } from './text';
 
-const separator = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
+const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
 export const escsource: EscapableSourceParser = creator(source => {
   if (source === '') return;
-  const i = source.search(separator);
+  const i = source.search(delimiter);
   switch (i) {
     case -1:
       return [[source], ''];
@@ -22,7 +22,7 @@ export const escsource: EscapableSourceParser = creator(source => {
             ? source.search(nonWhitespace)
             : 1;
           assert(i > 0);
-          return [[source.slice(0, i)], source.slice(i)];
+          return [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
       }
     default:
       return [[source.slice(0, i)], source.slice(i)];

package/src/parser/source/text.test.ts

@@ -26,8 +26,8 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser(' \\\n')), [['<span class="linebreak"> </span>'], '']);
       assert.deepStrictEqual(inspect(parser('  \\\n')), [['<span class="linebreak"> </span>'], '']);
       assert.deepStrictEqual(inspect(parser(' a')), [[' ', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('  a')), [['  ', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('   a')), [['   ', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('  a')), [[' ', ' ', 'a'], '']);
+      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>'], '']);
@@ -35,8 +35,8 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('a \\\n')), [['a', '<span class="linebreak"> </span>'], '']);
       assert.deepStrictEqual(inspect(parser('a  \\\n')), [['a', '<span class="linebreak"> </span>'], '']);
       assert.deepStrictEqual(inspect(parser('a b')), [['a', ' ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('a  b')), [['a', '  ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('a   b')), [['a', '   ', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('a  b')), [['a', ' ', ' ', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('a   b')), [['a', '  ', ' ', 'b'], '']);
     });
 
     it('hardbreak', () => {

package/src/parser/source/text.ts

@@ -4,14 +4,14 @@ import { union, focus, creator } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
-export const separator = /[\s\x00-\x7F]|\S#|[、。！？][^\S\n]*(?=\\\n)/;
+export const delimiter = /[\s\x00-\x7F]|\S#|[、。！？][^\S\n]*(?=\\\n)/;
 export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S#|$/;
 const repeat = str(/^(.)\1*/);
 
 export const text: TextParser = creator((source, context) => {
   if (source === '') return;
-  const i = source.search(separator);
+  const i = source.search(delimiter);
   switch (i) {
     case -1:
       return [[source], ''];
@@ -70,7 +70,7 @@ export const text: TextParser = creator((source, context) => {
               || b && source[i] === '\n'
               || b && source[i] === '\\' && source[i + 1] === '\n'
             ? [[], source.slice(i)]
-            : [[source.slice(0, i)], source.slice(i)];
+            : [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
       }
     default:
       return [[source.slice(0, i)], source.slice(i)];

package/src/parser/source/unescapable.test.ts

@@ -18,10 +18,11 @@ describe('Unit: parser/source/unescapable', () => {
 
     it('space', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  ')), [['  '], '']);
-      assert.deepStrictEqual(inspect(parser('   ')), [['   '], '']);
+      assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
       assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n')), [['  ', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
     });
 
     it('linebreak', () => {

package/src/parser/source/unescapable.ts

@@ -1,11 +1,11 @@
 import { UnescapableSourceParser } from '../source';
 import { creator } from '../../combinator';
-import { separator, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
+import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
 
 export const unescsource: UnescapableSourceParser = creator(source => {
   assert(source[0] !== '\x1B');
   if (source === '') return;
-  const i = source.search(separator);
+  const i = source.search(delimiter);
   switch (i) {
     case -1:
       return [[source], ''];
@@ -15,7 +15,7 @@ export const unescsource: UnescapableSourceParser = creator(source => {
         ? source.search(b ? nonWhitespace : nonAlphanumeric) || 1
         : 1;
       assert(i > 0);
-      return [[source.slice(0, i)], source.slice(i)];
+      return [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
     }
     default:
       return [[source.slice(0, i)], source.slice(i)];

package/src/parser/util.ts

@@ -1,19 +1,25 @@
 import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../markdown';
 import { Parser, eval } from '../combinator/data/parser';
-import { union, some, verify, convert } from '../combinator';
+import { union, some, verify, convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
 import { linebreak, unescsource } from './source';
 import { invisibleHTMLEntityNames } from './api/normalize';
 import { reduce } from 'spica/memoize';
 import { push } from 'spica/array';
 
-export function blank(prefix: '' | RegExp, suffix: string | RegExp): RegExp {
+export const regBlankInlineStart = new RegExp(String.raw
+  `^(?:\\?[^\S\n]|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)+`);
+
+export function blankWith(delimiter: string | RegExp): RegExp;
+export function blankWith(starting: '' | '\n', delimiter: string | RegExp): RegExp;
+export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): RegExp {
+  if (delimiter === undefined) return blankWith('', starting);
   return new RegExp(String.raw
-    `^${
-      prefix && prefix.source
-    }(?:\\\s|[^\S\n]+|\n|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)?${
-      typeof suffix === 'string' ? suffix.replace(/[*+()\[\]]/g, '\\$&') : suffix.source
+    `^(?:(?=${
+      starting
+    })(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)${starting && '+'})?${
+      typeof delimiter === 'string' ? delimiter.replace(/[*+()\[\]]/g, '\\$&') : delimiter.source
     }`);
 }
 
@@ -53,9 +59,10 @@ export function startLoose<T extends HTMLElement | string>(parser: Parser<T>, ex
       ? parser(source, context)
       : undefined;
 }
-export const isStartLoose = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
-  return isStartTight(source.replace(/^[^\S\n]+/, ''), context, except);
+const isStartLoose = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
+  return isStartTight(source.replace(regBlankInlineStart, ''), context, except);
 }, (source, _, except = '') => `${source}\x1E${except}`);
+
 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) =>
@@ -130,10 +137,16 @@ function isVisible(node: HTMLElement | string, strpos?: number): boolean {
   }
 }
 
-export function trimSpaceStart<P extends Parser<unknown>>(parser: P): P;
-export function trimSpaceStart<T>(parser: Parser<T>): Parser<T> {
+export function trimBlankInline<P extends Parser<HTMLElement | string>>(parser: P): P;
+export function trimBlankInline<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+  return fmap(
+    trimBlankInlineStart(parser),
+    trimNodeEnd);
+}
+function trimBlankInlineStart<P extends Parser<unknown>>(parser: P): P;
+function trimBlankInlineStart<T>(parser: Parser<T>): Parser<T> {
   return convert(
-    reduce(source => source.replace(/^[^\S\n]+/, '')),
+    reduce(source => source.replace(regBlankInlineStart, '')),
     parser);
 }
 //export function trimNode(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
@@ -153,7 +166,7 @@ export function trimSpaceStart<T>(parser: Parser<T>): Parser<T> {
 //  }
 //  return nodes;
 //}
-export function trimNodeEnd(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
+export function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
   const skip = nodes.length > 0 &&
     typeof nodes[nodes.length - 1] === 'object' &&
     nodes[nodes.length - 1]['className'] === 'indexer'
@@ -163,7 +176,7 @@ export function trimNodeEnd(nodes: (HTMLElement | string)[]): (HTMLElement | str
     if (typeof node === 'string') {
       const pos = node.trimEnd().length;
       if (pos > 0) {
-        nodes[nodes.length - 1] = node.slice(0, pos);
+        nodes[nodes.length - 1] = node.slice(0, pos) as T;
         break;
       }
     }

package/src/renderer/render/media/image.ts

@@ -1,11 +1,11 @@
-import { ObjectFromEntries } from 'spica/alias';
+import { Object } from 'spica/global';
 import { Collection } from 'spica/collection';
 import { define } from 'typed-dom/dom';
 
 export function image(source: HTMLImageElement, url: URL, cache?: Collection<string, HTMLElement>): HTMLImageElement {
   if (cache?.has(url.href)) return define(
     cache.get(url.href)!.cloneNode(true) as HTMLImageElement,
-    ObjectFromEntries([...source.attributes]
+    Object.fromEntries([...source.attributes]
       .map(attr => [attr.name, attr.value])));
   define(source, {
     'data-type': 'image',
@@ -14,7 +14,7 @@ export function image(source: HTMLImageElement, url: URL, cache?: Collection<str
   });
   cache?.set(url.href, define(
     source.cloneNode(true),
-    ObjectFromEntries([...source.attributes]
+    Object.fromEntries([...source.attributes]
       .filter(attr => !['class', 'data-type', 'data-src', 'src', 'loading'].includes(attr.name))
       .map(attr => [attr.name, null]))));
   return source;

package/src/renderer/render/media/video.ts

@@ -1,4 +1,4 @@
-import { ObjectFromEntries } from 'spica/alias';
+import { Object } from 'spica/global';
 import { html } from 'typed-dom/dom';
 
 const extensions = [
@@ -11,7 +11,7 @@ export function video(source: HTMLImageElement, url: URL): HTMLVideoElement | un
   return html('video', {
     src: source.getAttribute('data-src'),
     'data-type': 'video',
-    ...ObjectFromEntries([...source.attributes]
+    ...Object.fromEntries([...source.attributes]
       .map(attr => [attr.name, attr.value])),
     muted: '',
     controls: '',