securemark 0.247.2 → 0.249.0

package/markdown.d.ts

@@ -28,12 +28,6 @@ export namespace MarkdownParser {
         readonly autolink?: boolean;
       };
     };
-    readonly state?: {
-      readonly in?: {
-        readonly supsub?: boolean;
-        readonly small?: boolean;
-      };
-    };
     readonly caches?: {
       readonly code?: Collection<string, HTMLElement>;
       readonly math?: Collection<string, HTMLElement>;
@@ -987,7 +981,6 @@ export namespace MarkdownParser {
         HTMLParser.OpenTagParser,
         HTMLParser.TagParser,
         HTMLParser.TagParser,
-        HTMLParser.TagParser,
       ]> {
     }
     export namespace HTMLParser {
@@ -1001,7 +994,6 @@ export namespace MarkdownParser {
         Inline<'html/tag'>,
         Parser<HTMLElement | string, Context, [
           InlineParser,
-          InlineParser,
         ]> {
       }
       export namespace TagParser {
@@ -1034,7 +1026,7 @@ export namespace MarkdownParser {
       Inline<'mark'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InlineParser,
+        MarkParser,
       ]> {
     }
     export interface EmStrongParser extends
@@ -1050,7 +1042,10 @@ export namespace MarkdownParser {
       Inline<'strong'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InlineParser,
+        Parser<HTMLElement | string, Context, [
+          EmStrongParser,
+          StrongParser,
+        ]>,
       ]> {
     }
     export interface EmphasisParser extends
@@ -1059,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.247.2",
+  "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/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
@@ -19,7 +18,7 @@ export const annotation: AnnotationParser = lazy(() => creator(validate('((', ')
     //label: true,
     //link: true,
     //autolink: true,
-  }}, state: undefined, delimiters: undefined },
-  trimSpaceStart(union([some(inline, ')', /^\\?\n/)]))))),
+  }}, delimiters: undefined },
+  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);
@@ -41,7 +42,7 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('</small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small/>')), undefined);
       assert.deepStrictEqual(inspect(parser('<b><b><b>a</b></b></b>')), [['<span class="invalid">&lt;b&gt;<span class="invalid">&lt;b&gt;<span class="invalid">&lt;b&gt;a&lt;/b&gt;</span>&lt;/b&gt;</span>&lt;/b&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<small><small><small>a</small></small></small>')), [['<small><span class="invalid">&lt;small&gt;<span class="invalid">&lt;small&gt;a&lt;/small&gt;</span>&lt;/small&gt;</span></small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small><small><small>a</small></small></small>')), [['<small><small><small>a</small></small></small>'], '']);
       assert.deepStrictEqual(inspect(parser('<x a="*b*"')), undefined);
       assert.deepStrictEqual(inspect(parser('<x a="*b*">')), undefined);
       assert.deepStrictEqual(inspect(parser('<x a="*b*">c')), 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>'], '']);
@@ -72,8 +75,8 @@ describe('Unit: parser/inline/html', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('<small><small>a</small></small>')), [['<small><span class="invalid">&lt;small&gt;a&lt;/small&gt;</span></small>'], '']);
-      assert.deepStrictEqual(inspect(parser('<small>a<small>b</small>c</small>')), [['<small>a<span class="invalid">&lt;small&gt;b&lt;/small&gt;</span>c</small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small><small>a</small></small>')), [['<small><small>a</small></small>'], '']);
+      assert.deepStrictEqual(inspect(parser('<small>a<small>b</small>c</small>')), [['<small>a<small>b</small>c</small>'], '']);
       assert.deepStrictEqual(inspect(parser('<small>`a`</small>')), [['<small><code data-src="`a`">a</code></small>'], '']);
     });
 

package/src/parser/inline/html.ts

@@ -1,15 +1,13 @@
-import { undefined } from 'spica/global';
-import { isFrozen, ObjectEntries } from 'spica/alias';
-import { MarkdownParser } from '../../../markdown';
+import { undefined, Object } from 'spica/global';
 import { HTMLParser } from '../inline';
-import { union, some, validate, context, creator, surround, open, match, lazy } from '../../combinator';
+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 = {
@@ -31,78 +29,30 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
           [[h(tag as 'span', attributes('html', [], attrspec[tag], bs))], rest]),
     ([, tag]) => tags.indexOf(tag), [])),
   match(
-    /^(?=<(sup|sub|small)(?=[^\S\n]|>))/,
+    /^(?=<(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(
-        context((() => {
-          switch (tag) {
-            case 'sup':
-            case 'sub':
-              return {
-                state: { in: { supsub: true } },
-                syntax: { inline: {
-                  annotation: false,
-                  reference: false,
-                  media: false,
-                }},
-              };
-            case 'small':
-              return {
-                state: { in: { small: true } },
-                syntax: { inline: {
-                  media: false,
-                }},
-              };
-            default:
-              assert(false);
-              return {};
-          }
-        })(),
-        some(union([
-          some(inline, blank(/\n?/, `</${tag}>`)),
-          open(/^\n?/, some(inline, '</'), true),
-        ]), `</${tag}>`)), `</${tag}>`),
-        str(`</${tag}>`), false,
-        ([as, bs, cs], rest, context) =>
-          [[elem(tag, as, defrag(bs), cs, context)], rest])),
-    ([, tag]) => tags.indexOf(tag), [])),
-  match(
-    /^(?=<(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, '</'), true),
+          open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`)), true),
         ]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
-        ([as, bs, cs], rest, context) =>
-          [[elem(tag, as, defrag(bs), cs, context)], rest],
-        ([as, bs], rest) =>
-          as.length === 1 ? [unshift(as, bs), rest] : undefined)),
+        ([as, bs, cs], rest) =>
+          [[elem(tag, as, defrag(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, '</'), true),
+          open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`)), true),
         ]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
-        ([as, bs, cs], rest, context) =>
-          [[elem(tag, as, defrag(bs), cs, context)], rest],
-        ([as, bs], rest) =>
-          as.length === 1 ? [unshift(as, bs), rest] : undefined)),
+        ([as, bs, cs], rest) =>
+          [[elem(tag, as, defrag(bs), cs)], rest]),
     ([, tag]) => tag,
     new Cache(10000))),
 ])))));
@@ -111,35 +61,16 @@ export const attribute: HTMLParser.TagParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/),
 ]);
 
-function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: string[], context: MarkdownParser.Context): HTMLElement {
+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);
-  switch (tag) {
-    case 'sup':
-    case 'sub':
-      switch (true) {
-        case context.state?.in?.supsub:
-          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup> or <sub> HTML tag`, as, bs, cs);
-      }
-      break;
-    case 'small':
-      switch (true) {
-        case context.state?.in?.supsub:
-        case context.state?.in?.small:
-          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup>, <sub>, or <small> HTML tag`, as, bs, cs);
-      }
-      break;
-  }
   const attrs = attributes('html', [], attrspec[tag], as.slice(1, -1));
-  switch (true) {
-    case 'data-invalid-syntax' in attrs:
-      return invalid('attribute', 'Invalid HTML attribute', as, bs, cs);
-    default:
-      return h(tag as 'span', attrs, bs);
-  }
+  return 'data-invalid-syntax' in attrs
+    ? invalid('attribute', 'Invalid HTML attribute', as, bs, cs)
+    : h(tag as 'span', attrs, bs);
 }
 function invalid(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
   return h('span', {
@@ -152,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(
@@ -182,7 +113,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],