securemark 0.283.7 → 0.285.0

package/markdown.d.ts

@@ -652,8 +652,8 @@ export namespace MarkdownParser {
       InlineParser.TemplateParser,
       InlineParser.RemarkParser,
       InlineParser.ExtensionParser,
-      InlineParser.RubyParser,
       InlineParser.LinkParser.TextLinkParser,
+      InlineParser.RubyParser,
       InlineParser.HTMLParser,
       InlineParser.InsertionParser,
       InlineParser.DeletionParser,
@@ -661,6 +661,7 @@ export namespace MarkdownParser {
       InlineParser.EmStrongParser,
       InlineParser.StrongParser,
       InlineParser.EmphasisParser,
+      InlineParser.ItalicParser,
       InlineParser.MathParser,
       InlineParser.CodeParser,
       InlineParser.HTMLEntityParser,
@@ -815,20 +816,6 @@ export namespace MarkdownParser {
         ]> {
       }
     }
-    export interface RubyParser extends
-      // [AB](a b)
-      Inline<'ruby'>,
-      Parser<HTMLElement, Context, [
-        Parser<string[], Context, []>,
-        Parser<string[], Context, []>,
-      ]> {
-    }
-    export namespace RubyParser {
-      export interface TextParser extends
-        Inline<'ruby/text'>,
-        Parser<string[], Context, []> {
-      }
-    }
     export interface LinkParser extends
       // { uri }
       // [abc]{uri nofollow}
@@ -978,6 +965,20 @@ export namespace MarkdownParser {
         }
       }
     }
+    export interface RubyParser extends
+      // [AB](a b)
+      Inline<'ruby'>,
+      Parser<HTMLElement, Context, [
+        Parser<string[], Context, []>,
+        Parser<string[], Context, []>,
+      ]> {
+    }
+    export namespace RubyParser {
+      export interface TextParser extends
+        Inline<'ruby/text'>,
+        Parser<string[], Context, []> {
+      }
+    }
     export interface HTMLParser extends
       // Allow: wbr, bdo, bdi
       // <bdi>abc</bdi>
@@ -1015,7 +1016,7 @@ export namespace MarkdownParser {
       Inline<'insertion'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InlineParser,
+        InsertionParser,
       ]> {
     }
     export interface DeletionParser extends
@@ -1023,7 +1024,7 @@ export namespace MarkdownParser {
       Inline<'deletion'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InlineParser,
+        DeletionParser,
       ]> {
     }
     export interface MarkParser extends
@@ -1066,6 +1067,14 @@ export namespace MarkdownParser {
         ]>,
       ]> {
     }
+    export interface ItalicParser extends
+      // ///abc///
+      Inline<'italic'>,
+      Parser<HTMLElement | string, Context, [
+        InlineParser,
+        ItalicParser,
+      ]> {
+    }
     export interface MathParser extends
       // $expr$
       // ${expr}$

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.283.7",
+  "version": "0.285.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/parser/context.ts

@@ -31,11 +31,11 @@ export const enum Recursion {
 export const enum Backtrack {
   template = 7 << 2,
   index = 6 << 2,
-  ruby = 5 << 2,
-  link = 4 << 2,
+  link = 5 << 2,
+  ruby = 4 << 2,
   media = 3 << 2,
-  url = 2 << 2,
-  bracket = 1 << 2,
+  bracket = 2 << 2,
+  url = 1 << 2,
 }
 
 export const enum Command {

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

@@ -16,7 +16,7 @@ describe('Unit: parser/inline/autolink/url', () => {
       assert.deepStrictEqual(inspect(parser('Http://host')), [['Http'], '://host']);
       //assert.deepStrictEqual(inspect(parser('http://[::ffff:0:0%1]')), [['<a class="invalid">http://[::ffff:0:0%1]</a>'], '']);
       //assert.deepStrictEqual(inspect(parser('http://[::ffff:0:0/96]')), [['<a class="invalid">http://[::ffff:0:0/96]</a>'], '']);
-      assert.deepStrictEqual(inspect(parser(' http://a')), undefined);
+      assert.deepStrictEqual(inspect(parser(' http://host')), undefined);
     });
 
     it('basic', () => {

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

@@ -58,7 +58,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('[]')), [['[', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[a')), [['[', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[a]')), [['[', 'a', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[==]')), [['[', '==', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[==]')), [['[', '=', '=', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[$]$')), [['[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(']')), undefined);
     });
@@ -68,7 +68,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('{}')), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a')), [['{', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('{a}')), [['{', 'a', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('{==}')), [['{', '==', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('{==}')), [['{', '=', '=', '}'], '']);
       assert.deepStrictEqual(inspect(parser('}')), undefined);
     });
 

package/src/parser/inline/deletion.ts

@@ -1,19 +1,20 @@
 import { DeletionParser } from '../inline';
-import { Recursion } from '../context';
-import { union, some, creation, precedence, surround, open, lazy } from '../../combinator';
+import { Recursion, Command } from '../context';
+import { union, some, creation, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { str } from '../source';
 import { blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { repeat } from '../util';
+import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const deletion: DeletionParser = lazy(() => creation(1, Recursion.inline, surround(
-  str('~~', '~'),
-  precedence(0,
-  some(union([
-    some(inline, blankWith('\n', '~~')),
-    open('\n', some(inline, '~'), true),
-  ]))),
-  str('~~'), false,
-  ([, bs], rest) => [[html('del', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+export const deletion: DeletionParser = lazy(() => creation(1, Recursion.inline, validate('~~',
+  precedence(0, repeat('~~', surround(
+    '',
+    some(union([
+      some(inline, blankWith('\n', '~~')),
+      open('\n', some(deletion, '~'), true),
+    ])),
+    '~~', false,
+    ([, bs], rest) => [bs, rest],
+    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    nodes => [html('del', defrag(nodes))])))));

package/src/parser/inline/emphasis.ts

@@ -5,14 +5,14 @@ import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { strong } from './strong';
 import { str } from '../source';
-import { startTight, blankWith } from '../visibility';
+import { tightStart, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 export const emphasis: EmphasisParser = lazy(() => creation(1, Recursion.inline, surround(
   str('*', '*'),
   precedence(0,
-  startTight(some(union([
+  tightStart(some(union([
     strong,
     some(inline, blankWith('*')),
     open(some(inline, '*'), union([

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

@@ -0,0 +1,115 @@
+import { emstrong } from './emstrong';
+import { some } from '../../combinator';
+import { inspect } from '../../debug.test';
+
+describe('Unit: parser/inline/emstrong', () => {
+  describe('emstrong', () => {
+    const parser = (source: string) => some(emstrong)({ 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', '<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);
+    });
+
+    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>'], '']);
+    });
+
+    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'], ' *****']);
+    });
+
+  });
+
+});

package/src/parser/inline/emstrong.ts

@@ -1,14 +1,15 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
-import { Recursion } from '../context';
+import { Recursion, Command } from '../context';
 import { Result, IntermediateParser } from '../../combinator/data/parser';
-import { union, creation, precedence, some, surround, open, lazy, bind } from '../../combinator';
+import { union, some, creation, precedence, validate, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { startTight, blankWith } from '../visibility';
+import { tightStart, blankWith } from '../visibility';
+import { repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
-import { unshift } from 'spica/array';
+import { unshift, push } from 'spica/array';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
   some(inline, blankWith('**')),
@@ -27,36 +28,69 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => creation(1, Recursion.inline, surround(
-  str('***'),
-  precedence(0,
-  startTight(some(union([
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), inline),
-  ])))),
-  str(/^\*{1,3}/), false,
-  ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
-    assert(cs.length === 1);
-    switch (cs[0]) {
-      case '***':
-        return [[html('em', [html('strong', defrag(bs))])], rest];
-      case '**':
-        return bind<EmphasisParser>(
-          subemphasis,
-          (ds, rest) =>
-            rest.slice(0, 1) === '*'
-              ? [[html('em', unshift([html('strong', defrag(bs))], defrag(ds)))], rest.slice(1)]
-              : [unshift(['*', html('strong', defrag(bs))], ds), rest])
-          ({ source: rest, context }) ?? [['*', html('strong', defrag(bs))], rest];
-      case '*':
-        return bind<StrongParser>(
-          substrong,
-          (ds, rest) =>
-            rest.slice(0, 2) === '**'
-              ? [[html('strong', unshift([html('em', defrag(bs))], defrag(ds)))], rest.slice(2)]
-              : [unshift(['**', html('em', defrag(bs))], ds), rest])
-          ({ source: rest, context }) ?? [['**', html('em', defrag(bs))], rest];
-    }
-    assert(false);
-  },
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+// 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず早く閉じるよう解析しなければならない。
+// このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
+export const emstrong: EmStrongParser = lazy(() => creation(1, Recursion.inline, validate('***',
+  precedence(0, repeat('***', surround(
+    '',
+    tightStart(some(union([
+      some(inline, blankWith('*')),
+      open(some(inline, '*'), inline),
+    ]))),
+    str(/^\*{1,3}/), false,
+    ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
+      assert(cs.length === 1);
+      switch (cs[0]) {
+        case '***':
+          return [bs, rest];
+        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];
+        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];
+      }
+      assert(false);
+    },
+    ([as, bs], rest) => [push(unshift(as, bs), [Command.Escape]), rest]),
+    // 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) {
+          case 1:
+            acc = [[html('em', acc.flat())]];
+            i -= 1;
+            break;
+          case 2:
+            acc = [[html('strong', acc.flat())]];
+            i -= 2;
+            break;
+          default:
+            acc = [[html('em', [html('strong', acc.flat())])]];
+            i -= 3;
+        }
+      }
+      if (prefix > postfix) {
+        nodes.push('*'.repeat(prefix - postfix));
+      }
+      for (let i = 0; i < acc.length; ++i) {
+        nodes.push(...acc[i]);
+      }
+      if (postfix > 0) {
+        rest = rest.slice(postfix);
+      }
+      return [nodes, rest];
+    })))));

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

@@ -4,7 +4,7 @@ import { union, inits, some, creation, precedence, state, constraint, validate,
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str } from '../../source';
-import { startTight, trimBlankNodeEnd } from '../../visibility';
+import { tightStart, trimBlankNodeEnd } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
@@ -12,7 +12,7 @@ import IndexParser = ExtensionParser.IndexParser;
 export const index: IndexParser = lazy(() => constraint(State.index, false, creation(1, Recursion.ignore, fmap(indexee(surround(
   '[#',
   precedence(1, state(State.linkers | State.media,
-  startTight(
+  tightStart(
   some(inits([
     inline,
     signature,

package/src/parser/inline/extension/label.ts

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { State, Recursion } from '../../context';
-import { union, constraint, creation, surround, clear, fmap } from '../../../combinator';
+import { union, creation, constraint, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 

package/src/parser/inline/extension/placeholder.ts

@@ -3,7 +3,7 @@ import { Recursion, Backtrack } from '../../context';
 import { union, some, creation, precedence, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { startTight } from '../../visibility';
+import { tightStart } from '../../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -14,7 +14,7 @@ import { html, defrag } from 'typed-dom/dom';
 export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => creation(1, Recursion.inline, surround(
   str(/^\[[:^|]/),
   precedence(1,
-  startTight(some(union([inline]), ']', [[']', 1]]))),
+  tightStart(some(union([inline]), ']', [[']', 1]]))),
   str(']'), false,
   ([, bs], rest) => [[
     html('span', {

package/src/parser/inline/html.ts

@@ -3,7 +3,7 @@ import { Recursion } from '../context';
 import { union, subsequence, some, creation, precedence, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { isStartLooseNodes, blankWith } from '../visibility';
+import { isLooseNodeStart, blankWith } from '../visibility';
 import { memoize } from 'spica/memoize';
 import { Clock } from 'spica/clock';
 import { unshift, push, splice } from 'spica/array';
@@ -219,7 +219,7 @@ function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: strin
   if (!tags.includes(tag)) return invalid('tag', `Invalid HTML tag name "${tag}"`, as, bs, cs);
   if (cs.length === 0) return invalid('tag', `Missing the closing HTML tag "</${tag}>"`, as, bs, cs);
   if (bs.length === 0) return invalid('content', `Missing the content`, as, bs, cs);
-  if (!isStartLooseNodes(bs)) return invalid('content', `Missing the visible content in the same line`, as, bs, cs);
+  if (!isLooseNodeStart(bs)) return invalid('content', `Missing the visible content in the same line`, as, bs, cs);
   const attrs = attributes('html', [], attrspecs[tag], as.slice(1, -1));
   return 'data-invalid-syntax' in attrs
     ? invalid('attribute', 'Invalid HTML attribute', as, bs, cs)

package/src/parser/inline/insertion.ts

@@ -1,19 +1,20 @@
 import { InsertionParser } from '../inline';
-import { Recursion } from '../context';
-import { union, some, creation, precedence, surround, open, lazy } from '../../combinator';
+import { Recursion, Command } from '../context';
+import { union, some, creation, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { str } from '../source';
 import { blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { repeat } from '../util';
+import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const insertion: InsertionParser = lazy(() => creation(1, Recursion.inline, surround(
-  str('++', '+'),
-  precedence(0,
-  some(union([
-    some(inline, blankWith('\n', '++')),
-    open('\n', some(inline, '+'), true),
-  ]))),
-  str('++'), false,
-  ([, bs], rest) => [[html('ins', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+export const insertion: InsertionParser = lazy(() => creation(1, Recursion.inline, validate('++',
+  precedence(0, repeat('++', surround(
+    '',
+    some(union([
+      some(inline, blankWith('\n', '++')),
+      open('\n', some(insertion, '+'), true),
+    ])),
+    '++', false,
+    ([, bs], rest) => [bs, rest],
+    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    nodes => [html('ins', defrag(nodes))])))));