securemark 0.260.6 → 0.261.2

package/src/parser/inline/emphasis.ts

@@ -1,8 +1,6 @@
 import { EmphasisParser } from '../inline';
 import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { emstrong } from './emstrong';
-import { strong } from './strong';
 import { str } from '../source';
 import { Syntax, State } from '../context';
 import { startTight, blankWith } from '../visibility';
@@ -10,17 +8,12 @@ import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const emphasis: EmphasisParser = lazy(() => surround(
-  str('*'),
+  str('_', '_'),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
-    strong,
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), union([
-      emstrong,
-      strong,
-      emphasis,
-    ])),
-  ])), '*')),
-  str('*'), false,
+    some(inline, blankWith('_')),
+    open(some(inline, '_'), emphasis),
+  ])))),
+  str('_'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/extension/index.test.ts

@@ -53,7 +53,7 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#\\\\]')), [['<a class="index" href="#index:\\">\\</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#A]')), [['<a class="index" href="#index:A">A</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#==]')), [['<a class="index" href="#index:==">==</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#*A*]')), [['<a class="index" href="#index:A"><em>A</em></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#_A_]')), [['<a class="index" href="#index:A"><em>A</em></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#`A`]')), [['<a class="index" href="#index:`A`"><code data-src="`A`">A</code></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#${A}$]')), [['<a class="index" href="#index:${A}$"><span class="math" translate="no" data-src="${A}$">${A}$</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#[A](a)]')), [['<a class="index" href="#index:A"><ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby></a>'], '']);
@@ -80,7 +80,7 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#a|#b ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|#b  ]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|#\\b]')), [['<a class="index" href="#index:b">a<span class="indexer" data-index="b"></span></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|#*b*]')), [['<a class="index" href="#index:*b*">a<span class="indexer" data-index="*b*"></span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|#_b_]')), [['<a class="index" href="#index:_b_">a<span class="indexer" data-index="_b_"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|#b c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|#b  c]')), [['<a class="index" href="#index:b_c">a<span class="indexer" data-index="b_c"></span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|#[]]')), [['<a class="index" href="#index:[]">a<span class="indexer" data-index="[]"></span></a>'], '']);

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

@@ -37,8 +37,8 @@ describe('Unit: parser/inline/insertion', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('++*++a++*++')), [['<ins><em><ins>a</ins></em></ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++*~~a~~*++')), [['<ins><em><del>a</del></em></ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++_++a++_++')), [['<ins><em><ins>a</ins></em></ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++_~~a~~_++')), [['<ins><em><del>a</del></em></ins>'], '']);
     });
 
   });

package/src/parser/inline/insertion.ts

@@ -8,7 +8,7 @@ import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const insertion: InsertionParser = lazy(() => surround(
-  str('++'),
+  str('++', '+'),
   syntax(Syntax.none, 1, 1, State.none,
   some(union([
     some(inline, blankWith('\n', '++')),

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

@@ -170,7 +170,7 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[((a))]{b}')), [['<a class="link" href="b"><span class="paren">((a))</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]]{b}')), [['<a class="link" href="b">[[a]]</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[!http://host]{/}')), [['<a class="link" href="/" target="_blank"><img class="media" data-src="http://host" alt=""></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[*a*]{b}')), [['<a class="link" href="b"><em>a</em></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[_a_]{b}')), [['<a class="link" href="b"><em>a</em></a>'], '']);
     });
 
     it('external', () => {

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

@@ -40,7 +40,7 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('==a\\ ==b====')), [['<mark>a <mark>b</mark></mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark>a\t<mark>b</mark></mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==a<wbr>==b====')), [['<mark>a<wbr><mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==*==a==*==')), [['<mark><em><mark>a</mark></em></mark>'], '']);
+      assert.deepStrictEqual(inspect(parser('==_==a==_==')), [['<mark><em><mark>a</mark></em></mark>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -8,7 +8,7 @@ import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const mark: MarkParser = lazy(() => surround(
-  str('=='),
+  str('==', '='),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('==')),

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

@@ -7,44 +7,37 @@ describe('Unit: parser/inline/strong', () => {
     const parser = (source: string) => some(strong)({ source, context: {} });
 
     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*')), [['**', 'a', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
-      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('*')), 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('* *')), 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);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('**a**')), [['<strong>a</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**ab**')), [['<strong>ab</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\nb**')), [['<strong>a<br>b</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\\\nb**')), [['<strong>a<span class="linebreak"> </span>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a*')), [['<strong>a</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*ab*')), [['<strong>ab</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['<strong>a<br>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['<strong>a<span class="linebreak"> </span>b</strong>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('**a *b***')), [['<strong>a <em>b</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a **b****')), [['<strong>a <strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a&Tab;**b****')), [['<strong>a\t<strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a<wbr>**b****')), [['<strong>a<wbr><strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b*c**')), [['<strong>a<em>b</em>c</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b*c**d')), [['<strong>a<em>b</em>c</strong>'], 'd']);
-      assert.deepStrictEqual(inspect(parser('**`a`**')), [['<strong><code data-src="`a`">a</code></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**(*a*)**')), [['<strong><span class="paren">(<em>a</em>)</span></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**(**a**)**')), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a _b_*')), [['<strong>a <em>b</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a *b**')), [['<strong>a <strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a&Tab;*b**')), [['<strong>a\t<strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a<wbr>*b**')), [['<strong>a<wbr><strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*(*a*)*')), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
     });
 
   });

package/src/parser/inline/strong.ts

@@ -1,7 +1,6 @@
 import { StrongParser } from '../inline';
 import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { emstrong } from './emstrong';
 import { str } from '../source';
 import { Syntax, State } from '../context';
 import { startTight, blankWith } from '../visibility';
@@ -9,15 +8,12 @@ import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const strong: StrongParser = lazy(() => surround(
-  str('**'),
+  str('*', '*'),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
-    some(inline, blankWith('**')),
-    open(some(inline, '*'), union([
-      emstrong,
-      strong,
-    ])),
-  ])), '*')),
-  str('**'), false,
+    some(inline, blankWith('*')),
+    open(some(inline, '*'), strong),
+  ])))),
+  str('*'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline.test.ts

@@ -21,91 +21,14 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('+++a+++')), [['+++', 'a', '+++'], '']);
       assert.deepStrictEqual(inspect(parser('~~~a~~~')), [['~~~', 'a', '~~~'], '']);
       assert.deepStrictEqual(inspect(parser('===a===')), [['===', 'a', '==='], '']);
-      assert.deepStrictEqual(inspect(parser('* a*')), [['*', ' ', 'a', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('** a**')), [['**', ' ', 'a', '**'], '']);
-      assert.deepStrictEqual(inspect(parser('*** a***')), [['***', ' ', 'a', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('**** a****')), [['****', ' ', 'a', '****'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**')), [['<em>a</em>', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b')), [['*', 'a', '**', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b*')), [['*', 'a', '**', 'b', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b*c')), [['*', 'a', '**', 'b', '*', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b*c*')), [['*', 'a', '**', 'b', '<em>c</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b**')), [['*', 'a', '<strong>b</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b**c')), [['*', 'a', '<strong>b</strong>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b***')), [['<em>a<strong>b</strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b***c')), [['<em>a<strong>b</strong></em>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b****')), [['<em>a<strong>b</strong></em>', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b****c')), [['*', 'a', '<strong>b</strong>', '**', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('*a***b****')), [['<em>a</em>', '<strong>b</strong>', '**'], '']);
-      assert.deepStrictEqual(inspect(parser('*a***b****c')), [['<em>a</em>', '<strong>b</strong>', '**', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('*a *b**')), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a *b**c')), [['*', 'a', ' ', '*', 'b', '**', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('*a **b***')), [['<em>a <strong>b</strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a **b***c')), [['<em>a <strong>b</strong></em>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('*a ***b****')), [['<em>a <em><strong>b</strong></em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a ***b****c')), [['<em>a <em><strong>b</strong></em></em>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*')), [['**', 'a', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b**c')), [['**', 'a', '*', 'b', '**', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b***')), [['<strong>a<em>b</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a*b***c')), [['<strong>a<em>b</em></strong>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a**b****')), [['<strong>a</strong>', 'b', '****'], '']);
-      assert.deepStrictEqual(inspect(parser('**a**b****c')), [['<strong>a</strong>', 'b', '****', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a***b*****')), [['<strong>a</strong>', '<em>b</em>', '****'], '']);
-      assert.deepStrictEqual(inspect(parser('**a***b*****c')), [['<strong>a</strong>', '<em>b</em>', '****', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a *b***')), [['<strong>a <em>b</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a *b***c')), [['<strong>a <em>b</em></strong>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a **b****')), [['<strong>a <strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a **b****c')), [['<strong>a <strong>b</strong></strong>', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a ***b*****')), [['<strong>a <em><strong>b</strong></em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a ***b*****c')), [['<strong>a <em><strong>b</strong></em></strong>', 'c'], '']);
-      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*b*c***')), [['<strong><em>a</em>b<em>c</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b*c***d')), [['<strong><em>a</em>b<em>c</em></strong>', 'd'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b**c****')), [['<strong><em>a</em>b</strong>', 'c', '****'], '']);
-      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><strong>a <em>b</em></strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\\ *b****')), [['<em><strong>a <em>b</em></strong></em>'], '']);
-      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>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*')), [['***', 'a', ' ', '**', 'b', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\\ **b*')), [['***', 'a', ' ', '**', 'b', '*'], '']);
-      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***')), [['****', 'a', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('****a****')), [['****', 'a', '****'], '']);
-      assert.deepStrictEqual(inspect(parser('*(*a*)*')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('**(**a**)**')), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('*++ ++*')), [['<em><ins> </ins></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*++ a ++*')), [['<em><ins> a </ins></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*++  a  ++*')), [['<em><ins>  a  </ins></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*<bdi>`a`</bdi>*')), [['<em><bdi><code data-src="`a`">a</code></bdi></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>*<bdi>a</bdi>*</bdi>')), [['<bdi><em><bdi>a</bdi></em></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>((<bdi>((a))</bdi>))</bdi>')), [['<bdi><sup class="annotation"><span><bdi><span class="paren">((a))</span></bdi></span></sup></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>')), [['<bdi><sup class="reference"><span><bdi>[[a]]</bdi></span></sup></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('__a__')), [['__', 'a', '__'], '']);
+      assert.deepStrictEqual(inspect(parser('___a___')), [['___', 'a', '___'], '']);
+      assert.deepStrictEqual(inspect(parser('a_b_c')), [['a', '<em>b</em>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser('**a**')), [['**', 'a', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('***a***')), [['***', 'a', '***'], '']);
       assert.deepStrictEqual(inspect(parser('*[*]')), [['*', '[', '*', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('*<*>')), [['<em>&lt;</em>', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a((b))*')), [['<em>a<sup class="annotation"><span>b</span></sup></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*<*>')), [['<strong>&lt;</strong>', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a((b))*')), [['<strong>a<sup class="annotation"><span>b</span></sup></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('``a`')), [['``', 'a', '`'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]')), [['[', '<a class="account" href="/@a">@a</a>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[#1][#2]')), [['<a class="index" href="#index:1">1</a>', '<a class="index" href="#index:2">2</a>'], '']);
@@ -166,11 +89,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[~~a~~]')), [['[', '<del>a</del>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[^http://host')), [['[^', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<em>b<br>c</em>', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a class="url" href="/">/</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<strong>b<br>c</strong>', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<strong>a<br>b</strong>', ']', '<a class="url" href="/">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb]*')), [['[', '*', 'a', '<br>', 'b', ']', '*'], '']);
       assert.deepStrictEqual(inspect(parser('[*[a\nb*]')), [['', '[', '*', '[', 'a', '<br>', 'b', '*', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<strong>a<br>b</strong>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });
@@ -186,7 +109,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('0?!http://host')), [['0', '?', '<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('0!?http://host')), [['0', '!', '?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_http://host')), [['_', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('*http://host*')), [['<em><a class="url" href="http://host" target="_blank">http://host</a></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_http://host_')), [['<em><a class="url" href="http://host" target="_blank">http://host</a></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*http://host*')), [['<strong><a class="url" href="http://host" target="_blank">http://host</a></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('(http://host)')), [['<span class="paren">(<a class="url" href="http://host" target="_blank">http://host</a>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser(' http://host')), [[' ', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('あhttp://hostい')), [['あ', '<a class="url" href="http://host" target="_blank">http://host</a>', 'い'], '']);
@@ -195,7 +119,8 @@ describe('Unit: parser/inline', () => {
     it('email', () => {
       assert.deepStrictEqual(inspect(parser('a@b')), [['<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_a@b')), [['_', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a@b*')), [['<em><a class="email" href="mailto:a@b">a@b</a></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a@b_')), [['<em><a class="email" href="mailto:a@b">a@b</a></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a@b*')), [['<strong><a class="email" href="mailto:a@b">a@b</a></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('(a@b)')), [['<span class="paren">(<a class="email" href="mailto:a@b">a@b</a>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser(' a@b')), [[' ', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('++a++b@c++')), [['<ins>a</ins>', '<a class="email" href="mailto:b@c">b@c</a>', '++'], '']);
@@ -213,7 +138,8 @@ describe('Unit: parser/inline', () => {
     it('account', () => {
       assert.deepStrictEqual(inspect(parser('@a')), [['<a class="account" href="/@a">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_@a')), [['_', '<a class="account" href="/@a">@a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('*@a*')), [['<em><a class="account" href="/@a">@a</a></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_@a_')), [['<em><a class="account" href="/@a">@a</a></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*@a*')), [['<strong><a class="account" href="/@a">@a</a></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('(@a)')), [['<span class="paren">(<a class="account" href="/@a">@a</a>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser(' @a')), [[' ', '<a class="account" href="/@a">@a</a>'], '']);
     });
@@ -233,7 +159,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('「#あ」')), [['「', '<a class="hashtag" href="/hashtags/あ">#あ</a>', '」'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b')), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '<span class="linebreak"> </span>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a*#b')), [['<em>a</em>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a_#b')), [['<em>a</em>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a*#b')), [['<strong>a</strong>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a]]#b')), [['<sup class="reference"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a')), [['', '[', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);

package/src/parser/inline.ts

@@ -1,6 +1,5 @@
 import { MarkdownParser } from '../../markdown';
 import { union } from '../combinator';
-import { escape } from './inline/escape';
 import { annotation } from './inline/annotation';
 import { reference } from './inline/reference';
 import { template } from './inline/template';
@@ -13,7 +12,6 @@ import { html } from './inline/html';
 import { insertion } from './inline/insertion';
 import { deletion } from './inline/deletion';
 import { mark } from './inline/mark';
-import { emstrong } from './inline/emstrong';
 import { emphasis } from './inline/emphasis';
 import { strong } from './inline/strong';
 import { code } from './inline/code';
@@ -25,7 +23,6 @@ import { bracket } from './inline/bracket';
 import { text } from './source';
 
 export import InlineParser = MarkdownParser.InlineParser;
-export import EscapeParser = InlineParser.EscapeParser;
 export import AnnotationParser = InlineParser.AnnotationParser;
 export import ReferenceParser = InlineParser.ReferenceParser;
 export import TemplateParser = InlineParser.TemplateParser;
@@ -38,7 +35,6 @@ export import HTMLParser = InlineParser.HTMLParser;
 export import InsertionParser = InlineParser.InsertionParser;
 export import DeletionParser = InlineParser.DeletionParser;
 export import MarkParser = InlineParser.MarkParser;
-export import EmStrongParser = InlineParser.EmStrongParser;
 export import EmphasisParser = InlineParser.EmphasisParser;
 export import StrongParser = InlineParser.StrongParser;
 export import CodeParser = InlineParser.CodeParser;
@@ -50,7 +46,6 @@ export import AutolinkParser = InlineParser.AutolinkParser;
 export import BracketParser = InlineParser.BracketParser;
 
 export const inline: InlineParser = union([
-  escape,
   annotation,
   reference,
   template,
@@ -64,7 +59,6 @@ export const inline: InlineParser = union([
   insertion,
   deletion,
   mark,
-  emstrong,
   strong,
   emphasis,
   code,

package/src/parser/locale/ja.ts

@@ -1,11 +1,3 @@
 export function japanese(char: string): boolean {
-  switch (char) {
-    case '、':
-    case '。':
-    case '！':
-    case '？':
-      return true;
-    default:
-      return false;
-  }
+  return /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？]/u.test(char);
 }

package/src/parser/locale.test.ts

@@ -9,7 +9,7 @@ describe('Unit: parser/locale', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('。\\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('。 \\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('*。*\\\n0')), [['<p><em>。</em><span class="linebreak"></span>0</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('_。_\\\n0')), [['<p><em>。</em><span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('!> 。\\\n0')), [['<blockquote><section><p>。<span class="linebreak"></span>0</p><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('[。](a)\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[。　](a )\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);

package/src/parser/processor/figure.ts

@@ -141,7 +141,8 @@ export function* figure(
     }
     labels.add(label);
     opts.id !== '' && def.setAttribute('id', `label:${opts.id ? `${opts.id}:` : ''}${label}`);
-    for (const ref of refs.take(label, Infinity)) {
+    for (let rs = refs.take(label, Infinity), i = 0; i < rs.length; ++i) {
+      const ref = rs[i];
       if (ref.getAttribute('data-invalid-message') === messages.reference) {
         define(ref, {
           class: void ref.classList.remove('invalid'),

package/src/parser/processor/footnote.ts

@@ -114,7 +114,8 @@ function build(
       if (title && !blank && def.childNodes.length === 1) {
         def.insertBefore(content.cloneNode(true), def.lastChild);
         assert(def.childNodes.length > 1);
-        for (const ref of buffer.take(identifier, Infinity)) {
+        for (let refs = buffer.take(identifier, Infinity), i = 0; i < refs.length; ++i) {
+          const ref = refs[i];
           if (ref.getAttribute('data-invalid-type') !== 'content') continue;
           define(ref, {
             title,

package/src/parser/source/str.ts

@@ -3,12 +3,13 @@ import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
 import { creation } from '../../combinator';
 
-export function str(pattern: string | RegExp): StrParser;
-export function str(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
+export function str(pattern: string | RegExp, not?: string): StrParser;
+export function str(pattern: string | RegExp, not?: string): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
     ? creation(1, false, ({ source }) => {
         if (source === '') return;
+        if (not && source.slice(pattern.length, pattern.length + not.length) === not) return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
@@ -16,6 +17,7 @@ export function str(pattern: string | RegExp): Parser<string, Context<StrParser>
     : creation(1, false, ({ source }) => {
         if (source === '') return;
         const m = source.match(pattern);
+        if (m && not && source.slice(m[0].length, m[0].length + not.length) === not) return;
         return m && m[0].length > 0
           ? [[m[0]], source.slice(m[0].length)]
           : undefined;

package/src/parser/source/text.test.ts

@@ -14,6 +14,7 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('a')), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab')), [['ab'], '']);
       assert.deepStrictEqual(inspect(parser('09あいAZaz')), [['09', 'あい', 'AZaz'], '']);
+      assert.deepStrictEqual(inspect(parser('a_b')), [['a', '_', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('a\nb')), [['a', '<br>', 'b'], '']);
     });
 
@@ -116,10 +117,14 @@ describe('Unit: parser/text/text', () => {
     });
 
     it('localize', () => {
-      assert.deepStrictEqual(inspect(parser('.\\\n0')), [['.', '<span class="linebreak"> </span>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('。\\\n0')), [['。', '<span class="linebreak"></span>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('。 \\\n0')), [['。', '<span class="linebreak"></span>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('。。\\\n0')), [['。', '。', '<span class="linebreak"></span>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\n0')), [['a', '<span class="linebreak"> </span>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('あ\\\n０')), [['あ', '<span class="linebreak"></span>', '０'], '']);
+      assert.deepStrictEqual(inspect(parser('ア\\\n０')), [['ア', '<span class="linebreak"></span>', '０'], '']);
+      assert.deepStrictEqual(inspect(parser('亜\\\n０')), [['亜', '<span class="linebreak"></span>', '０'], '']);
+      assert.deepStrictEqual(inspect(parser('、\\\n０')), [['、', '<span class="linebreak"></span>', '０'], '']);
+      assert.deepStrictEqual(inspect(parser('。\\\n０')), [['。', '<span class="linebreak"></span>', '０'], '']);
+      assert.deepStrictEqual(inspect(parser('！？\\\n０')), [['！', '？', '<span class="linebreak"></span>', '０'], '']);
+      assert.deepStrictEqual(inspect(parser('\\あ\\\n０')), [['あ', '<span class="linebreak"></span>', '０'], '']);
     });
 
   });

package/src/parser/source/text.ts

@@ -4,9 +4,10 @@ import { union, creation, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /[\s\x00-\x7F]|\S[#>]|[（）、。！？][^\S\n]*(?=\\\n)/;
+export const delimiter = /[\s\x00-\x7F]|\S[#>]|[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
+const nssb = /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 const repeat = str(/^(.)\1*/);
 
 export const text: TextParser = creation(1, false, ({ source, context }) => {
@@ -19,21 +20,12 @@ export const text: TextParser = creation(1, false, ({ source, context }) => {
       switch (source[0]) {
         case '\x1B':
         case '\\':
-          switch (source[1]) {
-            case '、':
-            case '。':
-            case '！':
-            case '？':
-              assert(source[0] !== '\x1B');
-              return text({ source: source.slice(1), context });
-          }
-          break;
-        case '、':
-        case '。':
-        case '！':
-        case '？':
-          const i = source.slice(1).search(nonWhitespace) + 1;
-          if (i > 0 && source.slice(i, i + 2) === '\\\n') return [[source[0], html('span', { class: 'linebreak' })], source.slice(i + 2)];
+          if (!nssb.test(source.slice(1))) break;
+          assert(source[0] !== '\x1B');
+          return text({ source: source.slice(1), context });
+        default:
+          const i = source.match(nssb)?.[0].length ?? -1;
+          if (i !== -1) return [[source[0], html('span', { class: 'linebreak' })], source.slice(i + 2)];
       }
       switch (source[0]) {
         case '\x1B':
@@ -50,6 +42,7 @@ export const text: TextParser = creation(1, false, ({ source, context }) => {
           }
         case '\n':
           return [[html('br')], source.slice(1)];
+        case '_':
         case '*':
         case '+':
         case '~':