securemark 0.291.1 → 0.292.0

package/src/parser/inline/bracket.ts

@@ -17,54 +17,54 @@ export const bracket: BracketParser = lazy(() => union([
     precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
     str(')'),
     true,
-    ([as, bs = [], cs], rest, { recent = [] }) => [
-      indexA.test(recent[1])
-        ? recent
-        : [html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))],
-      rest
-    ],
-    ([as, bs = []], rest) => [unshift(as, bs), rest],
+    ([as, bs = [], 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)))]];
+    },
+    ([as, bs = []]) => [unshift(as, bs)],
     [2 | Backtrack.bracket]),
   surround(
     str('（'),
     precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
     str('）'),
     true,
-    ([as, bs = [], cs], rest, { recent = [] }) => [
-      indexF.test(recent[1])
-        ? recent
-        : [html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))],
-      rest
-    ],
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    ([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)))]];
+    },
+    ([as, bs = []]) => [unshift(as, bs)]),
   surround(
     str('['),
     precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
     str(']'),
     true,
-    ([as, bs = [], cs], rest, context) => {
+    ([as, bs = [], cs], context) => {
       if (context.state! & State.link) {
-        const { recent } = context;
-        const head = recent!.reduce((a, b) => a + b.length, rest.length);
-        if (context.linebreak! > 0 || rest[0] !== '{') {
+        const { source, position, range = 0 } = context;
+        const head = position - range;
+        if (context.linebreak !== 0 || source[position] !== '{') {
           setBacktrack(context, [2 | Backtrack.link], head);
         }
         else {
           context.state! ^= State.link;
-          assert(rest.length > 0);
-          const result = !isBacktrack(context, [1 | Backtrack.link], rest)
-            ? textlink({ source: rest, context })
+          const result = !isBacktrack(context, [1 | Backtrack.link])
+            ? textlink({ context })
             : undefined;
+          context.position = position;
           if (!result) {
             setBacktrack(context, [2 | Backtrack.link], head);
           }
           context.state! ^= State.link;
-          context.recent = recent;
+          context.range = range;
         }
       }
-      return [push(unshift(as, bs), cs), rest];
+      return [push(unshift(as, bs), cs)];
     },
-    ([as, bs = []], rest) => [unshift(as, bs), rest],
+    ([as, bs = []]) => [unshift(as, bs)],
     [2 | Backtrack.bracket]),
   surround(
     str('［'),
@@ -72,14 +72,14 @@ export const bracket: BracketParser = lazy(() => union([
     str('］'),
     true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    ([as, bs = []]) => [unshift(as, bs)]),
   surround(
     str('{'),
     precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
     str('}'),
     true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest],
+    ([as, bs = []]) => [unshift(as, bs)],
     [2 | Backtrack.bracket]),
   surround(
     str('｛'),
@@ -87,17 +87,17 @@ export const bracket: BracketParser = lazy(() => union([
     str('｝'),
     true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest]),
+    ([as, bs = []]) => [unshift(as, bs)]),
   // 同一行内でしか閉じない以外括弧と同じ挙動
   surround(
     str('"'),
     precedence(2, recursion(Recursion.bracket, some(inline, '"', [['"', 2, false]]))),
     str('"'),
     true,
-    ([as, bs = [], cs], rest, { linebreak = 0 }) =>
-      linebreak > rest.length
-        ? [unshift(as, bs), cs[0] + rest]
-        : [push(unshift(as, bs), cs), rest],
-    ([as, bs = []], rest) => [unshift(as, bs), rest],
+    ([as, bs = [], cs], context) =>
+      context.linebreak === 0
+        ? [push(unshift(as, bs), cs)]
+        : (context.position -= 1, [unshift(as, bs)]),
+    ([as, bs = []]) => [unshift(as, bs)],
     [2 | Backtrack.bracket]),
 ]));

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

@@ -1,52 +1,55 @@
 import { code } from './code';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/code', () => {
   describe('code', () => {
-    const parser = (source: string) => some(code)({ source, context: {} });
+    const parser = (source: string) => some(code)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('`')), undefined);
-      assert.deepStrictEqual(inspect(parser('``')), undefined);
-      assert.deepStrictEqual(inspect(parser('``a`')), undefined);
-      assert.deepStrictEqual(inspect(parser('`a``')), undefined);
-      assert.deepStrictEqual(inspect(parser('`\n`')), undefined);
-      assert.deepStrictEqual(inspect(parser('`a\nb`')), undefined);
-      assert.deepStrictEqual(inspect(parser('`a\\\nb`')), undefined);
-      assert.deepStrictEqual(inspect(parser(' ` `')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('`'), ctx), [['`'], '']);
+      assert.deepStrictEqual(inspect(parser('``'), ctx), [['``'], '']);
+      assert.deepStrictEqual(inspect(parser('``a`'), ctx), [['<code class="invalid">``a`</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`a``'), ctx), [ [ '<code class="invalid">`a``</code>' ], '' ]);
+      assert.deepStrictEqual(inspect(parser('`\n`'), ctx), [['`'], '\n`']);
+      assert.deepStrictEqual(inspect(parser('`a\nb`'), ctx), [['<code class="invalid">`a</code>'], '\nb`']);
+      assert.deepStrictEqual(inspect(parser('`a\\\nb`'), ctx), [['<code class="invalid">`a\\</code>'], '\nb`']);
+      assert.deepStrictEqual(inspect(parser(' ` `'), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('` `')), [['<code data-src="` `"> </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`  `')), [['<code data-src="`  `">  </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`   `')), [['<code data-src="`   `">   </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`a`')), [['<code data-src="`a`">a</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`ab`')), [['<code data-src="`ab`">ab</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`a`b')), [['<code data-src="`a`">a</code>'], 'b']);
-      assert.deepStrictEqual(inspect(parser('`a`b`')), [['<code data-src="`a`">a</code>'], 'b`']);
+      assert.deepStrictEqual(inspect(parser('` `'), ctx), [['<code data-src="` `"> </code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`  `'), ctx), [['<code data-src="`  `">  </code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`   `'), ctx), [['<code data-src="`   `">   </code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`a`'), ctx), [['<code data-src="`a`">a</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`ab`'), ctx), [['<code data-src="`ab`">ab</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`a`b'), ctx), [['<code data-src="`a`">a</code>'], 'b']);
+      assert.deepStrictEqual(inspect(parser('`a`b`'), ctx), [['<code data-src="`a`">a</code>'], 'b`']);
+      assert.deepStrictEqual(inspect(parser('`a`\n'), ctx), [['<code data-src="`a`">a</code>'], '\n']);
     });
 
     it('escape', () => {
-      assert.deepStrictEqual(inspect(parser('`\\`')), [['<code data-src="`\\`">\\</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`\\\\`')), [['<code data-src="`\\\\`">\\\\</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`&nbsp;`')), [['<code data-src="`&amp;nbsp;`">&amp;nbsp;</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('` `` `')), [['<code data-src="` `` `">``</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`` ` ``')), [['<code data-src="`` ` ``">`</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`\\`'), ctx), [['<code data-src="`\\`">\\</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`\\\\`'), ctx), [['<code data-src="`\\\\`">\\\\</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`&nbsp;`'), ctx), [['<code data-src="`&amp;nbsp;`">&amp;nbsp;</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('` `` `'), ctx), [['<code data-src="` `` `">``</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`` ` ``'), ctx), [['<code data-src="`` ` ``">`</code>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('`<wbr>`')), [['<code data-src="`&lt;wbr&gt;`">&lt;wbr&gt;</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`*u*`')), [['<code data-src="`*u*`">*u*</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`<wbr>`'), ctx), [['<code data-src="`&lt;wbr&gt;`">&lt;wbr&gt;</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`*u*`'), ctx), [['<code data-src="`*u*`">*u*</code>'], '']);
     });
 
     it('trim', () => {
-      assert.deepStrictEqual(inspect(parser('`a `')), [['<code data-src="`a `">a </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('` a`')), [['<code data-src="` a`"> a</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('` a `')), [['<code data-src="` a `">a</code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`  a  `')), [['<code data-src="`  a  `"> a </code>'], '']);
-      assert.deepStrictEqual(inspect(parser('`\ta\t`')), [['<code data-src="`\ta\t`">\ta\t</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`a `'), ctx), [['<code data-src="`a `">a </code>'], '']);
+      assert.deepStrictEqual(inspect(parser('` a`'), ctx), [['<code data-src="` a`"> a</code>'], '']);
+      assert.deepStrictEqual(inspect(parser('` a `'), ctx), [['<code data-src="` a `"> a </code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`  a  `'), ctx), [['<code data-src="`  a  `">  a  </code>'], '']);
+      assert.deepStrictEqual(inspect(parser('`\ta\t`'), ctx), [['<code data-src="`\ta\t`">\ta\t</code>'], '']);
     });
 
   });

package/src/parser/inline/code.ts

@@ -1,24 +1,31 @@
 import { CodeParser } from '../inline';
-import { validate, isBacktrack, setBacktrack, match } from '../../combinator';
+import { open, match } from '../../combinator';
 import { Backtrack } from '../context';
+import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-export const code: CodeParser = validate(
-  ({ source, context }) =>
-    source[0] === '`' &&
-    !isBacktrack(context, [1 | Backtrack.bracket], source),
+export const code: CodeParser = open(
+  /^(?=`)/,
   match(
-    /^(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|$|\n)/,
-    ([whole, , body, closer]) => ({ source, context }) =>
+    /^(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|(?=$|\n))/,
+    ([whole, opener, body, closer]) => () =>
       closer
-        ? [[html('code', { 'data-src': whole }, format(body))], source.slice(whole.length)]
-        : void setBacktrack(context, [2 | Backtrack.bracket], source.length),
-    true));
+        ? [[html('code', { 'data-src': whole }, format(body))]]
+        : body
+          ? [[html('code', {
+              class: 'invalid',
+              ...invalid('code', 'syntax', `Missing the closing symbol "${opener}"`)
+            }, whole)]]
+          : [[opener]],
+    true),
+  false,
+  [3 | Backtrack.bracket]);
 
 function format(text: string): string {
-  assert(text.length > 0);
-  return `${text[0]}${text.at(-1)}` === '  '
-      && text.trimStart()
+  return text.length > 2
+      && text[0] === ' '
+      && text[1] === '`'
+      && text.at(-1) === ' '
     ? text.slice(1, -1)
     : text;
 }

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

@@ -1,44 +1,46 @@
 import { deletion } from './deletion';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/deletion', () => {
   describe('deletion', () => {
-    const parser = (source: string) => some(deletion)({ source, context: {} });
+    const parser = (source: string) => some(deletion)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~a')), [['~~', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a~')), [['~~', 'a', '~'], '']);
-      assert.deepStrictEqual(inspect(parser(' ~~a~~')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('~'), ctx), undefined);
+      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), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('~~a~~')), [['<del>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a~b~~')), [['<del>a~b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~ ~~')), [['<del> </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~ a~~')), [['<del> a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~ a ~~')), [['<del> a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~  a  ~~')), [['<del>  a  </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~\na~~')), [['<del><br>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~\\\na~~')), [['<del><br>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~<wbr>a~~')), [['<del><wbr>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a ~~')), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a \n ~~')), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\n~~')), [['<del>a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\n ~~')), [['<del>a </del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\n<wbr>~~')), [['<del>a<wbr></del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\nb~~')), [['<del>a<br>b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a\\\nb~~')), [['<del>a<br>b</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~\\~~~')), [['<del>~</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~a~~~')), [['<del>a</del>'], '~']);
+      assert.deepStrictEqual(inspect(parser('~~a~~'), ctx), [['<del>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a~b~~'), ctx), [['<del>a~b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~ ~~'), ctx), [['<del> </del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~ a~~'), ctx), [['<del> a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~ a ~~'), ctx), [['<del> a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~  a  ~~'), ctx), [['<del>  a  </del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~\na~~'), ctx), [['<del><br>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~\\\na~~'), ctx), [['<del><br>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~<wbr>a~~'), ctx), [['<del><wbr>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a ~~'), ctx), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a \n ~~'), ctx), [['<del>a  </del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a\n~~'), ctx), [['<del>a</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a\n ~~'), ctx), [['<del>a </del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a\n<wbr>~~'), ctx), [['<del>a<wbr></del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a\nb~~'), ctx), [['<del>a<br>b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a\\\nb~~'), ctx), [['<del>a<br>b</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~\\~~~'), ctx), [['<del>~</del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~a~~~'), ctx), [['<del>a</del>'], '~']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('~~*~~a~~*~~')), [['<del><em><del>a</del></em></del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~*++a++*~~')), [['<del><em><ins>a</ins></em></del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~*~~a~~*~~'), ctx), [['<del><em><del>a</del></em></del>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~*++a++*~~'), ctx), [['<del><em><ins>a</ins></em></del>'], '']);
     });
 
   });

package/src/parser/inline/deletion.ts

@@ -16,6 +16,6 @@ export const deletion: DeletionParser = lazy(() => validate('~~',
       open('\n', some(deletion, '~'), true),
     ]))),
     '~~', false,
-    ([, bs], rest) => [bs, rest],
-    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    ([, bs], { buffer }) => [push(buffer!, bs)],
+    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
     nodes => [html('del', defrag(nodes))]))));

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

@@ -1,53 +1,57 @@
 import { emphasis } from './emphasis';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/emphasis', () => {
   describe('emphasis', () => {
-    const parser = (source: string) => some(emphasis)({ source, context: {} });
+    const parser = (source: string) => some(emphasis)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      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'], '\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);
-      assert.deepStrictEqual(inspect(parser('* a*')), undefined);
-      assert.deepStrictEqual(inspect(parser('* a *')), 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**')), undefined);
-      assert.deepStrictEqual(inspect(parser('***a***')), undefined);
-      assert.deepStrictEqual(inspect(parser(' *a*')), undefined);
+      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'], '\n*']);
+      assert.deepStrictEqual(inspect(parser('*a\\ *'), ctx), [['*', 'a'], '\\ *']);
+      assert.deepStrictEqual(inspect(parser('*a\\\n*'), ctx), [['*', 'a'], '\\\n*']);
+      assert.deepStrictEqual(inspect(parser('*a**b'), ctx), [['*', 'a', '**', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('* *'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('* a*'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('* a *'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('*\n*'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('*\na*'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('*\\ a*'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('*\\\na*'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('*<wbr>a*'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('**a**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('***a***'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' *a*'), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('*a*')), [['<em>a</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*ab*')), [['<em>ab</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**')), [['<em>a</em>'], '*']);
-      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['<em>a<br>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['<em>a<br>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a*'), ctx), [['<em>a</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*ab*'), ctx), [['<em>ab</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a**'), ctx), [['<em>a</em>'], '*']);
+      assert.deepStrictEqual(inspect(parser('*a\nb*'), ctx), [['<em>a<br>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a\\\nb*'), ctx), [['<em>a<br>b</em>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('*a *b**')), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a **b***')), [['<em>a <strong>b</strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\\ *b**')), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a&Tab;*b**')), [['<em>a\t<em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a<wbr>*b**')), [['<em>a<wbr><em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b**c*')), [['<em>a<strong>b</strong>c</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b**c*d')), [['<em>a<strong>b</strong>c</em>'], 'd']);
-      assert.deepStrictEqual(inspect(parser('*`a`*')), [['<em><code data-src="`a`">a</code></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*(*a*)*')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*(**a**)*')), [['<em><span class="paren">(<strong>a</strong>)</span></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a *b**'), ctx), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a **b***'), ctx), [['<em>a <strong>b</strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a\\ *b**'), ctx), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a&Tab;*b**'), ctx), [['<em>a\t<em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a<wbr>*b**'), ctx), [['<em>a<wbr><em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a**b*'), ctx), [['<em>a**b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a**b**'), ctx), [[ '*', 'a', '<strong>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a**b**c'), ctx), [['*', 'a', '<strong>b</strong>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser('*a**b**c*'), ctx), [['<em>a<strong>b</strong>c</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a**b**c*d'), ctx), [['<em>a<strong>b</strong>c</em>'], 'd']);
+      assert.deepStrictEqual(inspect(parser('*`a`*'), ctx), [['<em><code data-src="`a`">a</code></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*(*a*)*'), ctx), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*(**a**)*'), ctx), [['<em><span class="paren">(<strong>a</strong>)</span></em>'], '']);
     });
 
   });

package/src/parser/inline/emphasis.ts

@@ -22,5 +22,5 @@ export const emphasis: EmphasisParser = lazy(() => surround(
     ])),
   ]))))),
   str('*'), false,
-  ([, bs], rest) => [[html('em', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]));
+  ([, bs]) => [[html('em', defrag(bs))]],
+  ([as, bs]) => bs && [unshift(as, bs)]));