securemark 0.291.1 → 0.292.0

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

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

package/src/parser/inline/emstrong.ts

@@ -1,6 +1,6 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
-import { Result, IntermediateParser } from '../../combinator/data/parser';
+import { Result, Node, Context, IntermediateParser } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
@@ -8,14 +8,16 @@ import { emphasis } from './emphasis';
 import { str } from '../source';
 import { tightStart, blankWith } from '../visibility';
 import { repeat } from '../util';
-import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
-  some(inline, blankWith('**')),
+  emphasis,
+  some(inline, blankWith('*')),
   open(some(inline, '*'), union([
     emstrong,
     strong,
+    emphasis,
   ])),
 ])));
 const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
@@ -37,62 +39,120 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
     recursion(Recursion.inline,
     tightStart(some(union([
       some(inline, blankWith('*')),
-      open(some(inline, '*'), inline),
+      open(some(inline, '*'), union([
+        emstrong,
+        strong,
+        emphasis,
+      ])),
     ])))),
     str(/^\*{1,3}/), false,
-    ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
+    ([, bs, cs], context): Result<Node<EmStrongParser>, Context<EmStrongParser>> => {
       assert(cs.length === 1);
+      const { buffer } = context;
       switch (cs[0]) {
         case '***':
-          return [bs, rest];
+          return [bs];
         case '**':
           return bind<EmphasisParser>(
             subemphasis,
-            (ds, rest) =>
-              rest.slice(0, 1) === '*'
-                ? [[html('em', unshift([html('strong', defrag(bs))], defrag(ds))), Command.Separator], rest.slice(1)]
-                : [push(unshift(['*', html('strong', defrag(bs))], ds), [Command.Separator]), rest])
-            ({ source: rest, context }) ?? [['*', html('strong', defrag(bs)), Command.Separator], rest];
+            ds => {
+              const { source } = context;
+              if (source.startsWith('*', context.position)) {
+                context.position += 1;
+                return [[html('em', push(push(buffer!, [html('strong', defrag(bs))]), defrag(ds))), Command.Separator]];
+              }
+              else {
+                return [prepend('*', push(push(push(buffer!, [html('strong', defrag(bs))]), defrag(ds)), [Command.Separator]))];
+              }
+            })
+            ({ context }) ?? [prepend('*', push(push(buffer!, [html('strong', defrag(bs))]), [Command.Separator]))];
         case '*':
           return bind<StrongParser>(
             substrong,
-            (ds, rest) =>
-              rest.slice(0, 2) === '**'
-                ? [[html('strong', unshift([html('em', defrag(bs))], defrag(ds))), Command.Separator], rest.slice(2)]
-                : [push(unshift(['**', html('em', defrag(bs))], ds), [Command.Separator]), rest])
-            ({ source: rest, context }) ?? [['**', html('em', defrag(bs)), Command.Separator], rest];
+            ds => {
+              const { source } = context;
+              if (source.startsWith('**', context.position)) {
+                context.position += 2;
+                return [[html('strong', push(push(buffer!, [html('em', defrag(bs))]), defrag(ds))), Command.Separator]];
+              }
+              else {
+                return [prepend('**', push(push(push(buffer!, [html('em', defrag(bs))]), defrag(ds)), [Command.Separator]))];
+              }
+            })
+            ({ context }) ?? [prepend('**', push(push(buffer!, [html('em', defrag(bs))]), [Command.Separator]))];
       }
       assert(false);
     },
-    ([as, bs], rest) => [push(unshift(as, bs), [Command.Escape]), rest]),
+    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
     // 3以上の`*`に対してemの適用を保証する
     nodes => [html('em', [html('strong', defrag(nodes))])],
-    (acc, rest, prefix, postfix, state) => {
-      const nodes = [];
-      let i = postfix;
-      if (state) while (i > 0) {
-        switch (i) {
+    (nodes, context, prefix, postfix, state) => {
+      context.position += postfix;
+      assert(postfix < 3);
+      if (state) {
+        switch (postfix) {
+          case 0:
+            break;
           case 1:
-            acc = [[html('em', acc.flat())]];
-            i -= 1;
+            nodes = [html('em', defrag(nodes))];
             break;
           case 2:
-            acc = [[html('strong', acc.flat())]];
-            i -= 2;
+            nodes = [html('strong', defrag(nodes))];
             break;
           default:
-            acc = [[html('em', [html('strong', acc.flat())])]];
-            i -= 3;
+            assert(false);
+        }
+        prefix -= postfix;
+        postfix -= postfix;
+        switch (prefix) {
+          case 0:
+            break;
+          case 1:
+            nodes = bind<EmphasisParser>(
+              subemphasis,
+              ds => {
+                const { source } = context;
+                if (source.startsWith('*', context.position)) {
+                  context.position += 1;
+                  return [[html('em', push(nodes, defrag(ds)))]];
+                }
+                else {
+                  return [prepend('*', push(nodes, defrag(ds)))];
+                }
+              })
+              ({ context })?.[0] ?? prepend('*', nodes);
+            prefix -= 1;
+            break;
+          case 2:
+            nodes = bind<StrongParser>(
+              substrong,
+              ds => {
+                const { source } = context;
+                if (source.startsWith('**', context.position)) {
+                  context.position += 2;
+                  return [[html('strong', push(nodes, defrag(ds)))]];
+                }
+                else {
+                  return [prepend('**', push(nodes, defrag(ds)))];
+                }
+              })
+              ({ context })?.[0] ?? prepend('**', nodes);
+            prefix -= 2;
+            break;
         }
       }
       if (prefix > postfix) {
-        nodes.push('*'.repeat(prefix - postfix));
+        nodes = push(['*'.repeat(prefix - postfix)], nodes);
       }
-      for (let i = 0; i < acc.length; ++i) {
-        nodes.push(...acc[i]);
-      }
-      if (postfix > 0) {
-        rest = rest.slice(postfix);
-      }
-      return [nodes, rest];
+      return [nodes];
     }))));
+
+function prepend<N>(prefix: string, nodes: N[]): N[] {
+  if (typeof nodes[0] === 'string') {
+    nodes[0] = prefix + nodes[0] as N;
+  }
+  else {
+    unshift([prefix], nodes);
+  }
+  return nodes;
+}