securemark 0.248.0 → 0.249.1

package/karma.conf.js

@@ -12,7 +12,7 @@ module.exports = function (config) {
       { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.3.8/purify.js', watched: false, served: false, included: true, integrity: 'sha512-QaF+0tDlqVmwZaQSc0kImgYmw+Cd66TxA5D9X70I5V9BNSqk6yBTbyqw2VEUsVYV5OTbxw8HD9d45on1wvYv7g==' },
       { pattern: 'dist/**/*.{js,map}', watched: true, served: true, included: true },
     ],
-    reporters: ['dots', 'coverage'],
+    reporters: ['dots'],
     preprocessors: {
       'dist/**/*.js': ['coverage'],
     },

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.0",
+  "version": "0.249.1",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -34,11 +34,11 @@
     "@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.27.1",
     "babel-loader": "^8.2.5",
     "babel-plugin-unassert": "^3.2.0",
-    "concurrently": "^7.2.0",
-    "eslint": "^8.16.0",
+    "concurrently": "^7.2.1",
+    "eslint": "^8.17.0",
     "eslint-plugin-redos": "^4.4.0",
     "eslint-webpack-plugin": "^3.1.1",
     "glob": "^8.0.3",
@@ -49,22 +49,22 @@
     "karma-mocha": "^2.0.1",
     "karma-power-assert": "^1.0.0",
     "mocha": "^10.0.0",
-    "npm-check-updates": "^13.0.3",
+    "npm-check-updates": "^13.1.1",
     "semver": "^7.3.7",
-    "spica": "0.0.551",
+    "spica": "0.0.564",
     "ts-loader": "^9.3.0",
-    "typed-dom": "^0.0.295",
-    "typescript": "4.6.4",
-    "webpack": "^5.72.1",
+    "typed-dom": "^0.0.298",
+    "typescript": "4.7.3",
+    "webpack": "^5.73.0",
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"
   },
   "scripts": {
     "update": "ncu -u && npm i --no-shrinkwrap && bundle update",
-    "dev": "concurrently \"webpack --env mode=test -w\" \"karma start --auto-watch --reporters dots\" \"webpack --env mode=dist -w --output-path ./gh-pages/assets/dist\" \"bundle exec jekyll serve -s ./gh-pages -d ./gh-pages/_site --incremental\"",
-    "test": "webpack --env mode=test && karma start --single-run --concurrency 1",
+    "dev": "concurrently \"webpack --env mode=test -w\" \"karma start --auto-watch\" \"webpack --env mode=dist -w --output-path ./gh-pages/assets/dist\" \"bundle exec jekyll serve -s ./gh-pages -d ./gh-pages/_site --incremental\"",
+    "test": "webpack --env mode=test && karma start --single-run --concurrency 1 --reporters dots,coverage",
     "lint": "webpack --env mode=lint",
-    "bench": "webpack --env mode=bench && karma start --single-run --concurrency 1 --reporters dots",
+    "bench": "webpack --env mode=bench && karma start --single-run --concurrency 1",
     "dist": "webpack --env mode=dist"
   },
   "author": "falsandtru",

package/src/combinator/control/manipulation/indent.ts

@@ -7,7 +7,6 @@ import { bind } from '../monad/bind';
 import { match } from './match';
 import { open } from './surround';
 import { memoize } from 'spica/memoize';
-import { join } from 'spica/array';
 
 export function indent<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
 export function indent<T>(parser: Parser<T>, separation = false): Parser<T> {
@@ -19,7 +18,7 @@ export function indent<T>(parser: Parser<T>, separation = false): Parser<T> {
       some(line(open(indent, source => [[unline(source)], '']))),
     ([, indent]) => indent.length * 2 + +(indent[0] === ' '), [])), separation),
     (nodes, rest, context) => {
-      const result = parser(join(nodes, '\n'), context);
+      const result = parser(nodes.join('\n'), context);
       return result && exec(result) === ''
         ? [eval(result), rest]
         : undefined;

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/extension/index.ts

@@ -6,7 +6,6 @@ import { indexee, identity } from './indexee';
 import { txt, str, stropt } from '../../source';
 import { startTight, trimNodeEnd } from '../../util';
 import { html, define, defrag } from 'typed-dom/dom';
-import { join } from 'spica/array';
 
 import IndexParser = ExtensionParser.IndexParser;
 
@@ -44,7 +43,7 @@ const signature: IndexParser.SignatureParser = lazy(() => creator(fmap(open(
   '|#',
   startTight(some(union([bracket, txt]), ']'))),
   ns => [
-    html('span', { class: 'indexer', 'data-index': identity(join(ns)).slice(6) }),
+    html('span', { class: 'indexer', 'data-index': identity(ns.join('')).slice(6) }),
   ])));
 
 const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creator(union([

package/src/parser/inline/extension/label.ts

@@ -3,7 +3,6 @@ import { ExtensionParser } from '../../inline';
 import { union, validate, guard, creator, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
-import { join } from 'spica/array';
 
 const body = str(/^\$[A-Za-z]*(?:(?:-[A-Za-z][0-9A-Za-z]*)+|-(?:(?:0|[1-9][0-9]*)\.)*(?:0|[1-9][0-9]*)(?![0-9A-Za-z]))/);
 
@@ -48,5 +47,5 @@ function increment(number: string, position: number): string {
           ? 0
           : 1;
   }
-  return join(ms, '.');
+  return ms.join('.');
 }

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,14 +1,13 @@
-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';
-import { unshift, push, splice, join } from 'spica/array';
+import { unshift, push, splice } from 'spica/array';
 
 const tags = Object.freeze(['wbr', 'sup', 'sub', 'small', 'bdo', 'bdi']);
 const attrspec = {
@@ -33,35 +32,27 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
     /^(?=<(sup|sub|small|bdo|bdi)(?=[^\S\n]|>))/,
     memoize(
     ([, tag]) =>
-      validate(`<${tag}`, `</${tag}>`,
       surround<HTMLParser.TagParser, string>(surround(
         str(`<${tag}`), some(attribute), str(/^\s*>/), true),
         startLoose(some(union([
-          some(inline, blank(/\n/, `</${tag}>`)),
-          open(/^\n/, some(inline, `</${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],
-        ([as, bs], rest) =>
-          as.length === 1 ? [unshift(as, bs), rest] : undefined)),
+          [[elem(tag, as, bs, cs)], rest]),
     ([, tag]) => tags.indexOf(tag), [])),
   match(
     /^(?=<([a-z]+)(?=[^\S\n]|>))/,
     memoize(
     ([, tag]) =>
-      validate(`<${tag}`, `</${tag}>`,
       surround<HTMLParser.TagParser, string>(surround(
         str(`<${tag}`), some(attribute), str(/^\s*>/), true),
         startLoose(some(union([
-          some(inline, blank(/\n/, `</${tag}>`)),
-          open(/^\n/, some(inline, `</${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],
-        ([as, bs], rest) =>
-          as.length === 1 ? [unshift(as, bs), rest] : undefined)),
+          [[elem(tag, as, bs, cs)], rest]),
     ([, tag]) => tag,
     new Cache(10000))),
 ])))));
@@ -73,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', {
@@ -92,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(
@@ -122,7 +112,7 @@ export function attributes(
   }
   invalid ||= !!spec && !requiredAttributes(spec).every(name => name in attrs);
   if (invalid) {
-    attrs['class'] = join(classes.includes('invalid') ? classes : unshift(classes, ['invalid']), ' ');
+    attrs['class'] = (classes.includes('invalid') ? classes : unshift(classes, ['invalid'])).join(' ');
     attrs['data-invalid-syntax'] = syntax;
     attrs['data-invalid-type'] = 'argument';
     attrs['data-invalid-message'] = 'Invalid argument';

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