securemark 0.248.1 → 0.249.0

package/markdown.d.ts

@@ -994,7 +994,6 @@ export namespace MarkdownParser {
         Inline<'html/tag'>,
         Parser<HTMLElement | string, Context, [
           InlineParser,
-          InlineParser,
         ]> {
       }
       export namespace TagParser {
@@ -1027,7 +1026,7 @@ export namespace MarkdownParser {
       Inline<'mark'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InlineParser,
+        MarkParser,
       ]> {
     }
     export interface EmStrongParser extends
@@ -1043,7 +1042,10 @@ export namespace MarkdownParser {
       Inline<'strong'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InlineParser,
+        Parser<HTMLElement | string, Context, [
+          EmStrongParser,
+          StrongParser,
+        ]>,
       ]> {
     }
     export interface EmphasisParser extends
@@ -1052,7 +1054,11 @@ export namespace MarkdownParser {
       Parser<HTMLElement | string, Context, [
         StrongParser,
         InlineParser,
-        InlineParser,
+        Parser<HTMLElement | string, Context, [
+          EmStrongParser,
+          StrongParser,
+          EmphasisParser,
+        ]>,
       ]> {
     }
     export interface CodeParser extends

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.248.1",
+  "version": "0.249.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -34,10 +34,10 @@
     "@types/mocha": "9.1.1",
     "@types/power-assert": "1.5.8",
     "@types/prismjs": "1.26.0",
-    "@typescript-eslint/parser": "^5.25.0",
+    "@typescript-eslint/parser": "^5.26.0",
     "babel-loader": "^8.2.5",
     "babel-plugin-unassert": "^3.2.0",
-    "concurrently": "^7.2.0",
+    "concurrently": "^7.2.1",
     "eslint": "^8.16.0",
     "eslint-plugin-redos": "^4.4.0",
     "eslint-webpack-plugin": "^3.1.1",
@@ -51,10 +51,10 @@
     "mocha": "^10.0.0",
     "npm-check-updates": "^13.0.3",
     "semver": "^7.3.7",
-    "spica": "0.0.551",
+    "spica": "0.0.554",
     "ts-loader": "^9.3.0",
-    "typed-dom": "^0.0.295",
-    "typescript": "4.6.4",
+    "typed-dom": "^0.0.297",
+    "typescript": "4.7.2",
     "webpack": "^5.72.1",
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"

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

@@ -16,9 +16,7 @@ describe('Unit: parser/inline/annotation', () => {
       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/annotation', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('(( a))')), [['<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('(( a ))')), [['<sup class="annotation">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((\\ a))')), [['<sup class="annotation">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((<wbr>a))')), [['<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))')), [['<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((a ))')), [['<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((a  ))')), [['<sup class="annotation">a</sup>'], '']);

package/src/parser/inline/annotation.ts

@@ -2,13 +2,12 @@ import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
 import { union, some, validate, guard, context, creator, surround, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
-import { startLoose, trimSpaceStart, trimNodeEnd } from '../util';
+import { trimBlankInline } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => creator(validate('((', '))', '\n', fmap(surround(
   '((',
   guard(context => context.syntax?.inline?.annotation ?? true,
-  startLoose(
   context({ syntax: { inline: {
     annotation: false,
     // Redundant
@@ -20,6 +19,6 @@ export const annotation: AnnotationParser = lazy(() => creator(validate('((', ')
     //link: true,
     //autolink: true,
   }}, delimiters: undefined },
-  trimSpaceStart(union([some(inline, ')', /^\\?\n/)]))))),
+  trimBlankInline(some(union([inline]), ')', /^\\?\n/)))),
   '))'),
-  ns => [html('sup', { class: 'annotation' }, trimNodeEnd(defrag(ns)))]))));
+  ns => [html('sup', { class: 'annotation' }, defrag(ns))]))));

package/src/parser/inline/comment.ts

@@ -12,7 +12,7 @@ export const comment: CommentParser = lazy(() => creator(validate('[#', match(
   ([, fence]) =>
     surround(
       open(str(`[${fence}`), some(text, new RegExp(String.raw`^\s+${fence}\]|^\S`)), true),
-      union([some(inline, new RegExp(String.raw`^\s+${fence}\]`))]),
+      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`)),
       close(some(text, /^\S/), str(`${fence}]`)), true,
       ([as, bs = [], cs], rest) => [[
         html('span', { class: 'comment' }, [

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/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,8 +35,7 @@ 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),
+          open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`)), true),
         ]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest) =>
@@ -50,8 +48,7 @@ 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),
+          open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`)), true),
         ]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest) =>
@@ -86,7 +83,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 { trimBlankInline, 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/)))),
+        trimBlankInline(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 { 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,
@@ -23,17 +22,16 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
   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/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/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', () => {