securemark 0.293.4 → 0.294.0

package/src/parser/header.ts

@@ -1,13 +1,14 @@
 import { MarkdownParser } from '../../markdown';
+import { List, Data } from '../combinator/data/parser';
 import { union, inits, some, block, line, validate, focus, rewrite, clear, convert, lazy, fmap } from '../combinator';
 import { segment } from './segment';
 import { str } from './source';
-import { invalid } from './util';
+import { unwrap, invalid } from './util';
 import { normalize } from './api/normalize';
 import { html, defrag } from 'typed-dom/dom';
 
 export const header: MarkdownParser.HeaderParser = lazy(() => validate(
-  /---+[^\S\v\f\r\n]*\r?\n[^\S\n]*(?=\S)/y,
+  /---+[^\S\v\f\r\n]*\r?\n(?=\S)/y,
   inits([
     rewrite(
       ({ context }) => {
@@ -18,34 +19,33 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
         else {
           context.position = source.length;
         }
-        return [[]];
+        return new List();
       },
       block(
         union([
           validate(({ context }) => context.header ?? true,
-          focus(/---[^\S\v\f\r\n]*\r?\n(?:[A-Za-z][0-9A-Za-z]*(?:-[A-Za-z][0-9A-Za-z]*)*:[ \t]+\S[^\v\f\r\n]*\r?\n){1,100}---[^\S\v\f\r\n]*(?:$|\r?\n)/y,
+          focus(/(---+)[^\S\v\f\r\n]*\r?\n(?:[A-Za-z][0-9A-Za-z]*(?:-[A-Za-z][0-9A-Za-z]*)*:[ \t]+\S[^\v\f\r\n]*\r?\n){1,100}\1[^\S\v\f\r\n]*(?:$|\r?\n)/y,
           convert(source =>
             normalize(source.slice(source.indexOf('\n') + 1, source.trimEnd().lastIndexOf('\n'))).replace(/(\S)\s+$/mg, '$1'),
             fmap(
               some(union([field])),
-              es => [
-                html('aside', { class: 'header' }, [
-                  html('details', { open: '' }, defrag([
-                    html('summary', 'Header'),
-                    ...es,
-                  ])),
-                ]),
-              ]), false))),
+              ns => new List([
+                new Data(html('aside', { class: 'header' }, [
+                  html('details',
+                    { open: '' },
+                    defrag(unwrap(ns.unshift(new Data(html('summary', 'Header'))) && ns))),
+                ])),
+              ])), false))),
           ({ context }) => {
             const { source, position } = context;
             context.position += source.length;
-            return [[
-              html('pre', {
+            return new List([
+              new Data(html('pre', {
                 class: 'invalid',
                 translate: 'no',
                 ...invalid('header', 'syntax', 'Invalid syntax'),
-              }, normalize(source.slice(position))),
-            ]];
+              }, normalize(source.slice(position)))),
+            ]);
           },
         ]))),
     clear(str(/[^\S\v\f\r\n]*\r?\n/y)),
@@ -54,12 +54,12 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
 const field: MarkdownParser.HeaderParser.FieldParser = line(({ context: { source, position } }) => {
   const name = source.slice(position, source.indexOf(':', position));
   const value = source.slice(position + name.length + 1).trim();
-  return [[
-    html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
+  return new List([
+    new Data(html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
       html('span', { class: 'field-name' }, name),
       ': ',
       html('span', { class: 'field-value' }, value),
       '\n',
-    ]),
-  ]];
+    ])),
+  ]);
 });

package/src/parser/inline/annotation.ts

@@ -1,8 +1,10 @@
 import { AnnotationParser } from '../inline';
 import { State, Backtrack } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, precedence, state, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
@@ -13,7 +15,7 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
   false,
   ([, ns], context) =>
     context.linebreak === 0
-      ? [[html('sup', { class: 'annotation' }, [html('span', defrag(trimBlankNodeEnd(ns)))])]]
+      ? new List([new Data(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))])
       : undefined,
   undefined,
   [1 | Backtrack.bracket, 3 | Backtrack.doublebracket])));

package/src/parser/inline/autolink/account.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, tails, state, constraint, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
@@ -26,6 +27,6 @@ export const account: AutolinkParser.AccountParser = lazy(() => rewrite(
         } }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'account' })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'account' }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/anchor.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, state, constraint, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
@@ -30,6 +31,6 @@ export const anchor: AutolinkParser.AnchorParser = lazy(() => rewrite(
         } }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'anchor' })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'anchor' }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/channel.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, tails, sequence, some, state, constraint, verify, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { emoji } from './hashtag';
@@ -24,7 +25,7 @@ export const channel: AutolinkParser.ChannelParser = lazy(() => rewrite(
         str(new RegExp([
           /(?!['_])(?:[^\p{C}\p{S}\p{P}\s]|emoji|'(?=[0-9A-Za-z])|_(?=[^'\p{C}\p{S}\p{P}\s]|emoji))+(?![0-9a-z@]|>>|:\S|[^\p{C}\p{S}\p{P}\s]|emoji)/yu.source,
         ].join('').replace(/emoji/g, emoji), 'yu')),
-        ([source]) => !/^[0-9]{1,4}$|^[0-9]{5}/.test(source)),
+        ([{ value }]) => !/^[0-9]{1,4}$|^[0-9]{5}/.test(value)),
       false,
       [3 | Backtrack.autolink])),
   ]),
@@ -38,10 +39,10 @@ export const channel: AutolinkParser.ChannelParser = lazy(() => rewrite(
         } }`,
       unsafelink,
       false),
-      ([el], { source, position, range = 0 }) => {
+      ([{ value: el }], { source, position, range = 0 }) => {
         const src = source.slice(position - range, position);
         const url = `${el.getAttribute('href')}?ch=${src.slice(src.indexOf('#') + 1).replace(/#/g, '+')}`;
-        return [define(el, { class: 'channel', href: url }, src)];
+        return new List([new Data(define(el, { class: 'channel', href: url }, src))]);
       }))),
-    ({ context: { source } }) => [[source]],
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/email.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, state, constraint, verify, rewrite, open } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
@@ -10,11 +11,11 @@ export const email: AutolinkParser.EmailParser = rewrite(
   open(/(?<![0-9a-z][_.+-]?)(?=[0-9a-z])/yi,
     verify(
       str(/[0-9a-z](?:[_.+-](?=[0-9a-z])|[0-9a-z]){0,255}@[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?(?:\.[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?)*(?![0-9a-z@#]|>>|:\S)/yi),
-      ([source]) => source.length <= 255),
+      ([{ value }]) => value.length <= 255),
     false,
     [3 | Backtrack.autolink]),
   union([
     constraint(State.autolink, state(State.autolink,
-      ({ context: { source } }) => [[html('a', { class: 'email', href: `mailto:${source}` }, source)]])),
-    ({ context: { source } }) => [[source]],
+      ({ context: { source } }) => new List([new Data(html('a', { class: 'email', href: `mailto:${source}` }, source))]))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ]));

package/src/parser/inline/autolink/hashnum.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, state, constraint, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { emoji } from './hashtag';
@@ -21,6 +22,6 @@ export const hashnum: AutolinkParser.HashnumParser = lazy(() => rewrite(
       source => `[${source}]{ ${source.slice(1)} }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'hashnum', href: null })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'hashnum', href: null }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/hashtag.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, state, constraint, verify, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
@@ -19,7 +20,7 @@ export const hashtag: AutolinkParser.HashtagParser = lazy(() => rewrite(
       str(new RegExp([
         /(?!['_])(?:[^\p{C}\p{S}\p{P}\s]|emoji|'(?=[0-9A-Za-z])|_(?=[^'\p{C}\p{S}\p{P}\s]|emoji))+(?![0-9a-z@#]|>>|:\S|[^\p{C}\p{S}\p{P}\s]|emoji)/yu.source,
       ].join('').replace(/emoji/g, emoji), 'yu')),
-      ([source]) => !/^[0-9]{1,4}$|^[0-9]{5}/.test(source)),
+      ([{ value }]) => !/^[0-9]{1,4}$|^[0-9]{5}/.test(value)),
     false,
     [3 | Backtrack.autolink]),
   union([
@@ -27,6 +28,6 @@ export const hashtag: AutolinkParser.HashtagParser = lazy(() => rewrite(
       source => `[${source}]{ ${`/hashtags/${source.slice(1)}`} }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'hashtag' })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'hashtag' }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/url.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Recursion, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, tails, some, recursion, precedence, state, constraint, verify, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { unescsource, str } from '../../source';
@@ -18,7 +19,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => rewrite(
       url => `{ ${url} }`,
       unsafelink,
       false))),
-    ({ context: { source } }) => [[source]],
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));
 
 export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
@@ -30,17 +31,17 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
         url => `{ ${url} }`,
         unsafelink,
         false))),
-      ({ context: { source } }) => [[source]],
+      ({ context: { source } }) => new List([new Data(source)]),
     ]),
   ])));
 
 const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => union([
   surround(str('('), recursion(Recursion.terminal, some(union([bracket, unescsource]), ')')), str(')'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
   surround(str('['), recursion(Recursion.terminal, some(union([bracket, unescsource]), ']')), str(']'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
   surround(str('{'), recursion(Recursion.terminal, some(union([bracket, unescsource]), '}')), str('}'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
   surround(str('"'), precedence(2, recursion(Recursion.terminal, some(unescsource, '"'))), str('"'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
 ]));

package/src/parser/inline/bracket.ts

@@ -1,10 +1,11 @@
 import { BracketParser } from '../inline';
 import { State, Recursion, Backtrack } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
-import { unshift, push } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
@@ -38,13 +39,13 @@ const p1 = lazy(() => surround(
   precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
   str(')'),
   true,
-  ([as, bs = [], cs], { source, position, range = 0 }) => {
+  ([as, bs = new List(), cs], { source, position, range = 0 }) => {
     const str = source.slice(position - range + 1, position - 1);
     return indexA.test(str)
-      ? [[as[0], str, cs[0]]]
-      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+      ? new List([new Data(as.head!.value), new Data(str), new Data(cs.head!.value)])
+      : new List([new Data(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))]);
   },
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const p2 = lazy(() => surround(
@@ -55,10 +56,10 @@ const p2 = lazy(() => surround(
   ([as, bs = [], cs], { source, position, range = 0 }) => {
     const str = source.slice(position - range + 1, position - 1);
     return indexF.test(str)
-      ? [[as[0], str, cs[0]]]
-      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+      ? new List([new Data(as.head!.value), new Data(str), new Data(cs.head!.value)])
+      : new List([new Data(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))]);
   },
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const s1 = lazy(() => surround(
@@ -66,7 +67,7 @@ const s1 = lazy(() => surround(
   precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
   str(']'),
   true,
-  ([as, bs = [], cs], context) => {
+  ([as, bs = new List(), cs], context) => {
     if (context.state! & State.link) {
       const { source, position, range = 0 } = context;
       const head = position - range;
@@ -86,9 +87,9 @@ const s1 = lazy(() => surround(
         context.range = range;
       }
     }
-    return [push(unshift(as, bs), cs)];
+    return as.import(bs as List<Data<string>>).import(cs);
   },
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const s2 = lazy(() => surround(
@@ -97,7 +98,7 @@ const s2 = lazy(() => surround(
   str('］'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const c1 = lazy(() => surround(
@@ -106,7 +107,7 @@ const c1 = lazy(() => surround(
   str('}'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const c2 = lazy(() => surround(
@@ -115,7 +116,7 @@ const c2 = lazy(() => surround(
   str('｝'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const d1 = lazy(() => surround(
@@ -125,5 +126,5 @@ const d1 = lazy(() => surround(
   str('"'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));

package/src/parser/inline/code.ts

@@ -1,4 +1,5 @@
 import { CodeParser } from '../inline';
+import { List, Data } from '../../combinator/data/parser';
 import { open, match } from '../../combinator';
 import { Backtrack } from '../context';
 import { invalid } from '../util';
@@ -10,13 +11,13 @@ export const code: CodeParser = open(
     /(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|(?=$|\n))/y,
     ([whole, opener, body, closer]) => () =>
       closer
-        ? [[html('code', { 'data-src': whole }, format(body))]]
+        ? new List([new Data(html('code', { 'data-src': whole }, format(body)))])
         : body
-          ? [[html('code', {
+          ? new List([new Data(html('code', {
               class: 'invalid',
               ...invalid('code', 'syntax', `Missing the closing symbol "${opener}"`)
-            }, whole)]]
-          : [[opener]],
+            }, whole))])
+          : new List([new Data(opener)]),
     true),
   false,
   [3 | Backtrack.bracket]);

package/src/parser/inline/deletion.ts

@@ -1,10 +1,10 @@
 import { DeletionParser } from '../inline';
 import { Recursion, Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { blankWith } from '../visibility';
-import { repeat } from '../util';
-import { push } from 'spica/array';
+import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() => validate('~~',
@@ -16,6 +16,6 @@ export const deletion: DeletionParser = lazy(() => validate('~~',
       open('\n', some(inline, '~'), true),
     ]))),
     '~~', false,
-    ([, bs], { buffer }) => [push(buffer!, bs)],
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
-    nodes => [html('del', defrag(nodes))]))));
+    ([, bs], { buffer }) => buffer!.import(bs),
+    ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
+    nodes => new List([new Data(html('del', defrag(unwrap(nodes))))])))));

package/src/parser/inline/emphasis.ts

@@ -1,11 +1,12 @@
 import { EmphasisParser } from '../inline';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
 import { tightStart, blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const emphasis: EmphasisParser = lazy(() => surround(
@@ -17,5 +18,5 @@ export const emphasis: EmphasisParser = lazy(() => surround(
     open(some(inline, '*'), inline),
   ]))))),
   str('*'), false,
-  ([, bs]) => [[html('em', defrag(bs))]],
-  ([as, bs]) => bs && [unshift(as, bs)]));
+  ([, bs]) => new List([new Data(html('em', defrag(unwrap(bs))))]),
+  ([as, bs]) => bs && as.import(bs as List<Data<string>>)));

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

@@ -10,12 +10,12 @@ describe('Unit: parser/inline/emstrong', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('***'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('***a'), ctx), [['***', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('***a ***'), ctx), [['***', 'a', ' ', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a  ***'), ctx), [['***', 'a', ' ', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\n***'), ctx), [['***', 'a', '<br>', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\\ ***'), ctx), [['***', 'a', ' ', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\\\n***'), ctx), [['***', 'a', '<br>', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a'), ctx), [['***a'], '']);
+      assert.deepStrictEqual(inspect(parser('***a ***'), ctx), [['***a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a  ***'), ctx), [['***a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a\n***'), ctx), [['***a', '<br>', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a\\ ***'), ctx), [['***a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a\\\n***'), ctx), [['***a', '<br>', '***'], '']);
       assert.deepStrictEqual(inspect(parser('*** ***'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('*** a***'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('*** a ***'), ctx), undefined);
@@ -43,7 +43,7 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a*'), ctx), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b'), ctx), [['**', '<em>a</em>', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*'), ctx), [['**', '<em>a</em>', 'b'], '*']);
-      assert.deepStrictEqual(inspect(parser('***a*b*c'), ctx), [['**', '<em>a</em>', 'b*c'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b*c'), ctx), [['**', '<em>a</em>', 'b', '*', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*c*'), ctx), [['**', '<em>a</em>', 'b', '<em>c</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*c**'), ctx), [['**', '<em>a</em>', 'b', '<em>c</em>'], '*']);
       assert.deepStrictEqual(inspect(parser('***a*b*c***'), ctx), [['<strong><em>a</em>b<em>c</em></strong>'], '']);
@@ -53,7 +53,7 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a**b'), ctx), [['*', '<strong>a</strong>', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*'), ctx), [['<em><strong>a</strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**'), ctx), [['<em><strong>a</strong>b</em>'], '*']);
-      assert.deepStrictEqual(inspect(parser('***a**b**c'), ctx), [['*', '<strong>a</strong>', 'b**c'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b**c'), ctx), [['*', '<strong>a</strong>', 'b', '**', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c*'), ctx), [['<em><strong>a</strong>b**c</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c**'), ctx), [['*', '<strong>a</strong>', 'b', '<strong>c</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c***'), ctx), [['<em><strong>a</strong>b<strong>c</strong></em>'], '']);
@@ -66,8 +66,8 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a*\\ **b****'), ctx), [['<strong><em>a</em> <strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*&Tab;**b****'), ctx), [['<strong><em>a</em>\t<strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*<wbr>**b****'), ctx), [['<strong><em>a</em><wbr><strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b **'), ctx), [['**', '<em>a</em>', 'b **'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b\\ **'), ctx), [['**', '<em>a</em>', 'b **'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b **'), ctx), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b\\ **'), ctx), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*'), ctx), [['<em><strong>a</strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*c'), ctx), [['<em><strong>a</strong>b</em>'], 'c']);
       assert.deepStrictEqual(inspect(parser('***a**b*c**'), ctx), [['<em><strong>a</strong>b</em>'], 'c**']);
@@ -77,8 +77,8 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a**\\ *b**'), ctx), [['<em><strong>a</strong> <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**&Tab;*b**'), ctx), [['<em><strong>a</strong>\t<em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**<wbr>*b**'), ctx), [['<em><strong>a</strong><wbr><em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a**b *'), ctx), [['*', '<strong>a</strong>', 'b *'], '']);
-      assert.deepStrictEqual(inspect(parser('***a**b\\ *'), ctx), [['*', '<strong>a</strong>', 'b *'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b *'), ctx), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b\\ *'), ctx), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
       assert.deepStrictEqual(inspect(parser('***a*'), ctx), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**'), ctx), [['*', '<strong>a</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a***'), ctx), [['<em><strong>a</strong></em>'], '']);
@@ -108,12 +108,12 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('******a*****b*'), ctx), [['<em><strong><em><strong>a</strong></em></strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('******a******'), ctx), [['<em><strong><em><strong>a</strong></em></strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('******a******b'), ctx), [['<em><strong><em><strong>a</strong></em></strong></em>'], 'b']);
-      assert.deepStrictEqual(inspect(parser('******a*b'), ctx), [['***', '**', '<em>a</em>', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b *'), ctx), [['***', '**', '<em>a</em>', 'b *'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b **'), ctx), [['***', '**', '<em>a</em>', 'b **'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b ***'), ctx), [['***', '**', '<em>a</em>', 'b ***'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b ****'), ctx), [['***', '**', '<em>a</em>', 'b ****'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b *****'), ctx), [['***', '**', '<em>a</em>', 'b *****'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b'), ctx), [['*****', '<em>a</em>', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b *'), ctx), [['*****', '<em>a</em>', 'b', ' ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b **'), ctx), [['*****', '<em>a</em>', 'b', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b ***'), ctx), [['*****', '<em>a</em>', 'b', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b ****'), ctx), [['*****', '<em>a</em>', 'b', ' ', '****'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b *****'), ctx), [['*****', '<em>a</em>', 'b', ' ', '*****'], '']);
     });
 
   });