securemark 0.248.1 → 0.250.0

package/src/parser/inline/deletion.ts

@@ -2,15 +2,15 @@ import { DeletionParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { blank } from '../util';
+import { blankWith } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const deletion: DeletionParser = lazy(() => creator(surround(
   str('~~'),
   some(union([
-    some(inline, blank(/\n/, '~~')),
-    open(/^\n/, some(inline, '~'), true),
+    some(inline, blankWith('\n', '~~')),
+    open('\n', some(inline, '~'), true),
   ])),
   str('~~'), false,
   ([, bs], rest) => [[html('del', defrag(bs))], rest],

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

@@ -9,10 +9,11 @@ describe('Unit: parser/inline/emphasis', () => {
     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**b')), [['*', 'a', '**', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('*a**b*')), [['*', 'a', '**', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser('* *')), undefined);

package/src/parser/inline/emphasis.ts

@@ -1,9 +1,10 @@
 import { EmphasisParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
+import { emstrong } from './emstrong';
 import { strong } from './strong';
 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';
 
@@ -11,8 +12,12 @@ export const emphasis: EmphasisParser = lazy(() => creator(surround(
   str('*'),
   startTight(some(union([
     strong,
-    some(inline, blank('', '*')),
-    open(some(inline, '*'), inline),
+    some(inline, blankWith('*')),
+    open(some(inline, '*'), union([
+      emstrong,
+      strong,
+      emphasis,
+    ])),
   ])), '*'),
   str('*'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],

package/src/parser/inline/emstrong.ts

@@ -4,25 +4,33 @@ import { Result, IntermediateParser } from '../../combinator/data/parser';
 import { union, some, creator, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
+import { emphasis } from './emphasis';
 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';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
-  some(inline, blank('', '**')),
-  open(some(inline, '*'), inline),
+  some(inline, blankWith('**')),
+  open(some(inline, '*'), union([
+    emstrong,
+    strong,
+  ])),
 ])));
 const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   strong,
-  some(inline, blank('', '*')),
-  open(some(inline, '*'), inline),
+  some(inline, blankWith('*')),
+  open(some(inline, '*'), union([
+    emstrong,
+    strong,
+    emphasis,
+  ])),
 ])));
 
 export const emstrong: EmStrongParser = lazy(() => creator(surround(
   str('***'),
   startTight(some(union([
-    some(inline, blank('', '*')),
+    some(inline, blankWith('*')),
     open(some(inline, '*'), inline),
   ]))),
   str(/^\*{1,3}/), false,

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

@@ -45,7 +45,7 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#a \\ ]')), [['<a class="index" href="#index:a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a &nbsp;]')), [['<a class="index" href="#index:a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a <wbr>]')), [['<a class="index" href="#index:a">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a [# b #]]')), [['<a class="index" href="#index:a">a <span class="comment"><input type="checkbox"><span>[# b #]</span></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a [% b %]]')), [['<a class="index" href="#index:a">a <span class="comment"><input type="checkbox"><span>[% b %]</span></span></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:a_b">a b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#[]]')), [['<a class="index" href="#index:[]">[]</a>'], '']);
@@ -61,8 +61,8 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#@a]')), [['<a class="index" href="#index:@a">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#http://host]')), [['<a class="index" href="#index:http://host">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#!http://host]')), [['<a class="index" href="#index:!http://host">!http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#[#  #]]')), [['<a class="index"><span class="comment"><input type="checkbox"><span>[#  #]</span></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#[# a #]]')), [['<a class="index"><span class="comment"><input type="checkbox"><span>[# a #]</span></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#[%  %]]')), [['<a class="index"><span class="comment"><input type="checkbox"><span>[%  %]</span></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#[% a %]]')), [['<a class="index"><span class="comment"><input type="checkbox"><span>[% a %]</span></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a((b))]')), [['<a class="index" href="#index:a((b))">a<span class="paren">((b))</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a[[b]]]')), [['<a class="index" href="#index:a[[b]]">a[[b]]</a>'], '']);
     });
@@ -89,7 +89,7 @@ describe('Unit: parser/inline/extension/index', () => {
       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 #]|#c]')), [['<a class="index" href="#index:c">a <span class="comment"><input type="checkbox"><span>[# b #]</span></span><span class="indexer" data-index="c"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a [% b %]|#c]')), [['<a class="index" href="#index:c">a <span class="comment"><input type="checkbox"><span>[% b %]</span></span><span class="indexer" data-index="c"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a\\ |#b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
     });
 

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

@@ -45,13 +45,13 @@ describe('Unit: parser/inline/extension/placeholder', () => {
       assert.deepStrictEqual(inspect(parser('[^a\\ \\ ]')), [['<span class="invalid">a  </span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a<wbr>]')), [['<span class="invalid">a<wbr></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a<wbr><wbr>]')), [['<span class="invalid">a<wbr><wbr></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a[# b #]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[# b #]</span></span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a[# b #][# c #]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[# b #]</span></span><span class="comment"><input type="checkbox"><span>[# c #]</span></span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a[% b %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a[% b %][% c %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span><span class="comment"><input type="checkbox"><span>[% c %]</span></span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^\\]]')), [['<span class="invalid">]</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^(])]')), [['<span class="invalid"><span class="paren">(])</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^!http://host]')), [['<span class="invalid"><a href="http://host" target="_blank"><img class="media" data-src="http://host" alt=""></a></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^[# a #]]')), [['<span class="invalid"><span class="comment"><input type="checkbox"><span>[# a #]</span></span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^[# a #]b]')), [['<span class="invalid"><span class="comment"><input type="checkbox"><span>[# a #]</span></span>b</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^[% a %]]')), [['<span class="invalid"><span class="comment"><input type="checkbox"><span>[% a %]</span></span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^[% a %]b]')), [['<span class="invalid"><span class="comment"><input type="checkbox"><span>[% a %]</span></span>b</span>'], '']);
     });
 
   });

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

@@ -29,11 +29,12 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<small>z')), undefined);
       assert.deepStrictEqual(inspect(parser('<small></small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small> </small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small>\\ </small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small>&Tab;</small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small><wbr></small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small>\n</small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small>\na</small>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<small>\\ a</small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small>\\\na</small>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<small><wbr></small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small>a')), undefined);
       assert.deepStrictEqual(inspect(parser('<small>a</BDO>')), undefined);
       assert.deepStrictEqual(inspect(parser('<SMALL>a</SMALL>')), undefined);
@@ -60,6 +61,8 @@ describe('Unit: parser/inline/html', () => {
       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><wbr>a</small>')), [['<small><wbr>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>'], '']);

package/src/parser/inline/html.ts

@@ -1,10 +1,9 @@
-import { undefined } from 'spica/global';
-import { isFrozen, ObjectEntries } from 'spica/alias';
+import { undefined, Object } from 'spica/global';
 import { HTMLParser } from '../inline';
 import { union, some, validate, creator, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startLoose, blank } from '../util';
+import { startLoose, blankWith } from '../util';
 import { html as h, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { Cache } from 'spica/cache';
@@ -36,12 +35,11 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
       surround<HTMLParser.TagParser, string>(surround(
         str(`<${tag}`), some(attribute), str(/^\s*>/), true),
         startLoose(some(union([
-          some(inline, blank(/\n/, `</${tag}>`)),
-          open(/^\n/, some(inline, `</${tag}>`), true),
-        ]), `</${tag}>`), `</${tag}>`),
+          open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`)), true),
+        ])), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest) =>
-          [[elem(tag, as, defrag(bs), cs)], rest]),
+          [[elem(tag, as, bs, cs)], rest]),
     ([, tag]) => tags.indexOf(tag), [])),
   match(
     /^(?=<([a-z]+)(?=[^\S\n]|>))/,
@@ -50,12 +48,11 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
       surround<HTMLParser.TagParser, string>(surround(
         str(`<${tag}`), some(attribute), str(/^\s*>/), true),
         startLoose(some(union([
-          some(inline, blank(/\n/, `</${tag}>`)),
-          open(/^\n/, some(inline, `</${tag}>`), true),
-        ]), `</${tag}>`), `</${tag}>`),
+          open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`)), true),
+        ])), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest) =>
-          [[elem(tag, as, defrag(bs), cs)], rest]),
+          [[elem(tag, as, bs, cs)], rest]),
     ([, tag]) => tag,
     new Cache(10000))),
 ])))));
@@ -67,13 +64,12 @@ export const attribute: HTMLParser.TagParser.AttributeParser = union([
 function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: string[]): 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);
   const attrs = attributes('html', [], attrspec[tag], as.slice(1, -1));
   return 'data-invalid-syntax' in attrs
     ? invalid('attribute', 'Invalid HTML attribute', as, bs, cs)
-    : h(tag as 'span', attrs, bs);
+    : h(tag as 'span', attrs, defrag(bs));
 }
 function invalid(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
   return h('span', {
@@ -86,7 +82,7 @@ function invalid(type: string, message: string, as: (HTMLElement | string)[], bs
 
 const requiredAttributes = memoize(
   (spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>>) =>
-    ObjectEntries(spec).flatMap(([k, v]) => v && isFrozen(v) ? [k] : []),
+    Object.entries(spec).flatMap(([k, v]) => v && Object.isFrozen(v) ? [k] : []),
   new WeakMap());
 
 export function attributes(

package/src/parser/inline/insertion.ts

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

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

@@ -67,8 +67,6 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[[]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[a]{}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[\\ a]{b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[ \\ a]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[a\nb]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[a\\\nb]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[<wbr>]{b}')), undefined);
@@ -118,6 +116,8 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{^/b}', { host: new URL('/0.0,0.0,0z', location.origin) })), [[`<a href="/0.0,0.0,0z/b">^/b</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[ a]{b}')), [['<a href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[ a ]{b}')), [['<a href="b">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[\\ a]{b}')), [['<a href="b">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[ \\ a]{b}')), [['<a href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[a ]{b}')), [['<a href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[a  ]{b}')), [['<a href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[a]{b}')), [['<a href="b">a</a>'], '']);

package/src/parser/inline/link.ts

@@ -6,7 +6,7 @@ import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { autolink } from '../autolink';
 import { str } from '../source';
-import { startLoose, trimSpaceStart, trimNodeEnd, stringify } from '../util';
+import { trimBlank, stringify } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 
@@ -26,7 +26,6 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
       surround('[', shortmedia, ']'),
       surround(
         '[',
-        startLoose(
         context({ syntax: { inline: {
           annotation: false,
           reference: false,
@@ -37,7 +36,7 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
           media: false,
           autolink: false,
         }}},
-        trimSpaceStart(some(inline, ']', /^\\?\n/)))),
+        trimBlank(some(inline, ']', /^\\?\n/))),
         ']',
         true),
     ]))),
@@ -52,7 +51,7 @@ export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}',
     assert(!INSECURE_URI.match(/\s/));
     const el = elem(
       INSECURE_URI,
-      trimNodeEnd(defrag(content)),
+      defrag(content),
       new ReadonlyURL(
         resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
         context.host?.href || location.href),

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

@@ -12,10 +12,11 @@ describe('Unit: parser/inline/mark', () => {
       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  ==')), [['==', '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('== ==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a ==')), undefined);

package/src/parser/inline/mark.ts

@@ -2,15 +2,15 @@ import { MarkParser } from '../inline';
 import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 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 mark: MarkParser = lazy(() => creator(surround(
   str('=='),
   startTight(some(union([
-    some(inline, blank('', '==')),
-    open(some(inline, '='), inline),
+    some(inline, blankWith('==')),
+    open(some(inline, '='), mark),
   ]))),
   str('=='), false,
   ([, bs], rest) => [[html('mark', defrag(bs))], rest],

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 { regBlankStart, trimBlank, 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,
@@ -23,17 +22,16 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
   subsequence([
     abbr,
     focus(/^\^[^\S\n]*/, source => [['', source], '']),
-    trimSpaceStart(some(inline, ']', /^\\?\n/)),
-  ])))),
+    trimBlank(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(regBlankStart, '')]));
 
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
   return typeof ns[0] === 'object' && ns[0].tagName === 'ABBR'

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

@@ -166,8 +166,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>', '<em>b<br>c</em>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a href="/">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('"[# *"*"*')), [['"', '[#', ' ', '*', '"', '*', '"', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('"[# "*"* #]')), [['"', '[#', ' ', '"', '*', '"', '*', ' ', '#', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });
 
     it('uri', () => {

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)];