securemark 0.283.7 → 0.285.0

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

@@ -0,0 +1,72 @@
+import { italic } from './italic';
+import { some } from '../../combinator';
+import { inspect } from '../../debug.test';
+
+describe('Unit: parser/inline/italic', () => {
+  describe('italic', () => {
+    const parser = (source: string) => some(italic)({ 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/b')), [['///', 'a', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a//b')), [['///', 'a', '/', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a*b///')), [['///', 'a', '*', 'b', '/', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('/// ///')), undefined);
+      assert.deepStrictEqual(inspect(parser('/// a///')), undefined);
+      assert.deepStrictEqual(inspect(parser('/// a ///')), undefined);
+      assert.deepStrictEqual(inspect(parser('///\n///')), undefined);
+      assert.deepStrictEqual(inspect(parser('///\na///')), undefined);
+      assert.deepStrictEqual(inspect(parser('///\\ a///')), undefined);
+      assert.deepStrictEqual(inspect(parser('///\\\na///')), undefined);
+      assert.deepStrictEqual(inspect(parser('///<wbr>a///')), undefined);
+      assert.deepStrictEqual(inspect(parser(' ///a///')), undefined);
+    });
+
+    it('basic', () => {
+      assert.deepStrictEqual(inspect(parser('///a///')), [['<i>a</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///ab///')), [['<i>ab</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a////')), [['<i>a</i>'], '/']);
+      assert.deepStrictEqual(inspect(parser('///a\nb///')), [['<i>a<br>b</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\\\nb///')), [['<i>a<br>b</i>'], '']);
+    });
+
+    it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('////a///')), [['/', '<i>a</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('////a///b')), [['/', '<i>a</i>'], 'b']);
+      assert.deepStrictEqual(inspect(parser('////a////')), [['/', '<i>a</i>', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('////a////b')), [['/', '<i>a</i>', '/'], 'b']);
+      assert.deepStrictEqual(inspect(parser('/////a///')), [['//', '<i>a</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('/////a///b')), [['//', '<i>a</i>'], 'b']);
+      assert.deepStrictEqual(inspect(parser('/////a////')), [['//', '<i>a</i>', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('/////a////b')), [['//', '<i>a</i>', '/'], 'b']);
+      assert.deepStrictEqual(inspect(parser('/////a/////')), [['//', '<i>a</i>', '//'], '']);
+      assert.deepStrictEqual(inspect(parser('/////a/////b')), [['//', '<i>a</i>', '//'], 'b']);
+      assert.deepStrictEqual(inspect(parser('//////a///')), [['///', '<i>a</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a///b')), [['///', '<i>a</i>', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a////')), [['///', '<i>a</i>', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a////b')), [['///', '<i>a</i>', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////')), [['///', '<i>a</i>', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////b')), [['///', '<i>a</i>', '/', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a//////')), [['<i><i>a</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a///b///')), [['<i><i>a</i>b</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a ///b//////')), [['<i>a <i>b</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\\ ///b//////')), [['<i>a <i>b</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a //////b/////////')), [['<i>a <i><i>b</i></i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a ///b///c///')), [['<i>a <i>b</i>c</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a ///b ///c/////////')), [['<i>a <i>b <i>c</i></i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a&Tab;///b//////')), [['<i>a\t<i>b</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a<wbr>///b//////')), [['<i>a<wbr><i>b</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///`a`///')), [['<i><code data-src="`a`">a</code></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///(///a///)///')), [['<i><span class="paren">(<i>a</i>)</span></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///{http://host/}///')), [['<i><a class="url" href="http://host/" target="_blank">http://host/</a></i>'], '']);
+    });
+
+  });
+
+});

package/src/parser/inline/italic.ts

@@ -0,0 +1,22 @@
+import { ItalicParser } from '../inline';
+import { Recursion, Command } from '../context';
+import { union, some, creation, precedence, validate, surround, open, lazy } from '../../combinator';
+import { inline } from '../inline';
+import { tightStart, blankWith } from '../visibility';
+import { repeat } from '../util';
+import { push } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
+
+// 斜体は単語に使うとかえって見づらく読み飛ばしやすくなるため使わないべきであり
+// ある程度の長さのある文に使うのが望ましい。
+export const italic: ItalicParser = lazy(() => creation(1, Recursion.inline, validate('///',
+  precedence(0, repeat('///', surround(
+    '',
+    tightStart(some(union([
+      some(inline, blankWith('///')),
+      open(some(inline, '/'), italic),
+    ]))),
+    '///', false,
+    ([, bs], rest) => [bs, rest],
+    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    nodes => [html('i', defrag(nodes))])))));

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { MarkdownParser } from '../../../markdown';
 import { LinkParser } from '../inline';
 import { State, Recursion, Backtrack } from '../context';
-import { union, inits, tails, sequence, some, constraint, creation, precedence, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, sequence, some, creation, precedence, state, constraint, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { linebreak, unescsource, str } from '../source';

package/src/parser/inline/mark.ts

@@ -1,26 +1,27 @@
 import { MarkParser } from '../inline';
-import { State, Recursion } from '../context';
-import { union, some, creation, precedence, constraint, surround, open, lazy } from '../../combinator';
+import { State, Recursion, Command } from '../context';
+import { union, some, creation, precedence, constraint, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
-import { str } from '../source';
-import { startTight, blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { tightStart, blankWith } from '../visibility';
+import { repeat } from '../util';
+import { push } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => constraint(State.mark, false, creation(1, Recursion.inline, surround(
-  str('==', '='),
-  precedence(0,
-  startTight(some(union([
-    some(inline, blankWith('==')),
-    open(some(inline, '='), mark),
-  ])))),
-  str('=='), false,
-  ([, bs], rest, { id }) => {
-    const el = html('mark', defrag(bs));
-    return [[
-      define(el, { id: identity('mark', id, signature(el)) }),
-      el.id && html('a', { href: `#${el.id}` }),
-    ], rest];
-  },
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+export const mark: MarkParser = lazy(() => constraint(State.mark, false, creation(1, Recursion.inline, validate('==',
+  precedence(0, repeat('==', surround(
+    '',
+    tightStart(some(union([
+      some(inline, blankWith('==')),
+      open(some(inline, '='), mark),
+    ]))),
+    '==', false,
+    ([, bs], rest) => [bs, rest],
+    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    (nodes, { id }) => {
+      const el = html('mark', defrag(nodes));
+      define(el, { id: identity('mark', id, signature(el)) });
+      return el.id
+        ? [el, el.id && html('a', { href: `#${el.id}` })]
+        : [el];
+    }))))));

package/src/parser/inline/math.ts

@@ -36,7 +36,7 @@ const bracket: MathParser.BracketParser = lazy(() => creation(0, Recursion.termi
   str('{'),
   some(union([
     bracket,
-    some(escsource, /^(?:[{}$]|\\?\n)/),
+    some(escsource, /^[{}$\n]/),
   ])),
   str('}'),
   true)));

package/src/parser/inline/ruby.ts

@@ -4,7 +4,7 @@ import { eval, exec } from '../../combinator/data/parser';
 import { sequence, creation, surround, lazy, fmap, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
-import { isStartTightNodes } from '../visibility';
+import { isTightNodeStart } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -13,7 +13,7 @@ export const ruby: RubyParser = lazy(() => creation(1, Recursion.ignore, fmap(
     bind(surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {
       const ns = eval(text({ source, context }), [undefined])[0];
       ns && ns.at(-1) === '' && ns.pop();
-      return ns && isStartTightNodes(ns) ? [[ns], rest] : undefined;
+      return ns && isTightNodeStart(ns) ? [[ns], rest] : undefined;
     }),
     bind(surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {
       const ns = eval(text({ source, context }), [undefined])[0];
@@ -26,7 +26,8 @@ export const ruby: RubyParser = lazy(() => creation(1, Recursion.ignore, fmap(
         return [
           html('ruby', attributes(texts, rubies), defrag(texts
             .reduce((acc, _, i) =>
-              push(acc, unshift([texts[i]],
+              push(acc, unshift(
+                [texts[i]],
                 i < rubies.length && rubies[i]
                   ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                   : [html('rt')]))
@@ -36,7 +37,8 @@ export const ruby: RubyParser = lazy(() => creation(1, Recursion.ignore, fmap(
         return [
           html('ruby', attributes(texts, rubies), defrag([...texts[0]]
             .reduce((acc, _, i, texts) =>
-              push(acc, unshift([texts[i]],
+              push(acc, unshift(
+                [texts[i]],
                 i < rubies.length && rubies[i]
                   ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                   : [html('rt')]))

package/src/parser/inline/strong.ts

@@ -4,14 +4,14 @@ import { union, some, creation, precedence, surround, open, lazy } from '../../c
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 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 strong: StrongParser = lazy(() => creation(1, Recursion.inline, surround(
   str('**', '*'),
   precedence(0,
-  startTight(some(union([
+  tightStart(some(union([
     some(inline, blankWith('**')),
     open(some(inline, '*'), union([
       emstrong,

package/src/parser/inline/template.ts

@@ -20,6 +20,6 @@ const bracket: TemplateParser.BracketParser = lazy(() => creation(0, Recursion.t
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true,
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
-  surround(str('"'), precedence(2, some(escsource, /^"|^\\?\n/)), str('"'), true,
+  surround(str('"'), precedence(2, some(escsource, /^["\n]/)), str('"'), true,
     undefined, undefined, 3 | Backtrack.template),
 ])));

package/src/parser/inline.test.ts

@@ -20,9 +20,6 @@ describe('Unit: parser/inline', () => {
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('あ（Ａ）')), [['あ', '（', 'Ａ', '）'], '']);
       assert.deepStrictEqual(inspect(parser('あ（い）')), [['あ', '<span class="paren">（い）</span>'], '']);
-      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', '***'], '']);
@@ -47,6 +44,11 @@ describe('Unit: parser/inline', () => {
       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', '*', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*')), [['**', 'a', '<em>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c')), [['**', 'a', '<em>b</em>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c*')), [['**', 'a', '<em>b</em>', 'c', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c**')), [['<strong>a<em>b</em>c</strong>'], '']);
       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>'], '']);
@@ -61,41 +63,13 @@ describe('Unit: parser/inline', () => {
       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*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*)*')), [['<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>'], '']);
@@ -201,7 +175,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a@b*')), [['<em><a class="email" href="mailto:a@b">a@b</a></em>'], '']);
       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>', '++'], '']);
+      assert.deepStrictEqual(inspect(parser('++a++b@c++')), [['<ins>a</ins>', '<a class="email" href="mailto:b@c">b@c</a>', '+', '+'], '']);
     });
 
     it('channel', () => {

package/src/parser/inline.ts

@@ -5,8 +5,8 @@ import { reference } from './inline/reference';
 import { template } from './inline/template';
 import { remark } from './inline/remark';
 import { extension } from './inline/extension';
-import { ruby } from './inline/ruby';
 import { textlink } from './inline/link';
+import { ruby } from './inline/ruby';
 import { html } from './inline/html';
 import { insertion } from './inline/insertion';
 import { deletion } from './inline/deletion';
@@ -14,6 +14,7 @@ import { mark } from './inline/mark';
 import { emstrong } from './inline/emstrong';
 import { strong } from './inline/strong';
 import { emphasis } from './inline/emphasis';
+import { italic } from './inline/italic';
 import { math } from './inline/math';
 import { code } from './inline/code';
 import { htmlentity } from './inline/htmlentity';
@@ -27,8 +28,8 @@ export import ReferenceParser = InlineParser.ReferenceParser;
 export import TemplateParser = InlineParser.TemplateParser;
 export import RemarkParser = InlineParser.RemarkParser;
 export import ExtensionParser = InlineParser.ExtensionParser;
-export import RubyParser = InlineParser.RubyParser;
 export import LinkParser = InlineParser.LinkParser;
+export import RubyParser = InlineParser.RubyParser;
 export import HTMLParser = InlineParser.HTMLParser;
 export import InsertionParser = InlineParser.InsertionParser;
 export import DeletionParser = InlineParser.DeletionParser;
@@ -36,6 +37,7 @@ export import MarkParser = InlineParser.MarkParser;
 export import EmStrongParser = InlineParser.EmStrongParser;
 export import StrongParser = InlineParser.StrongParser;
 export import EmphasisParser = InlineParser.EmphasisParser;
+export import ItalicParser = InlineParser.ItalicParser;
 export import MathParser = InlineParser.MathParser;
 export import CodeParser = InlineParser.CodeParser;
 export import MediaParser = InlineParser.MediaParser;
@@ -75,11 +77,13 @@ export const inline: InlineParser = lazy(() => union([
         return deletion(input);
       case '==':
         return mark(input);
+      case '//':
+        return italic(input);
     }
     switch (source[0]) {
       case '[':
-        return ruby(input)
-            || textlink(input);
+        return textlink(input)
+            || ruby(input);
       case '{':
         return textlink(input);
       case '<':

package/src/parser/source/text.ts

@@ -34,9 +34,6 @@ export const text: TextParser = creation(1, Recursion.ignore, ({ source, context
         case '\n':
           return [[html('br')], source.slice(1)];
         case '*':
-        case '+':
-        case '~':
-        case '=':
         case '`':
           return source[1] === source[0]
             ? repeat({ source, context })

package/src/parser/util.ts

@@ -1,4 +1,6 @@
-import { Parser } from '../combinator/data/parser';
+import { min } from 'spica/alias';
+import { Command } from './context';
+import { Parser, Result, Ctx, Tree, Context, eval, exec } from '../combinator/data/parser';
 import { convert } from '../combinator';
 import { define } from 'typed-dom/dom';
 
@@ -7,6 +9,69 @@ export function lineable<T extends HTMLElement | string>(parser: Parser<T>): Par
   return convert(source => `\r${source}`, parser);
 }
 
+export function repeat<P extends Parser<HTMLElement | string>>(symbol: string, parser: P, cons: (nodes: Tree<P>[], context: Context<P>) => Tree<P>[], termination?: (acc: Tree<P>[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | Tree<P>>): P;
+export function repeat<T extends HTMLElement | string>(symbol: string, parser: Parser<T>, cons: (nodes: T[], context: Ctx) => T[], termination: (acc: T[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | T> = (acc, rest, prefix, postfix) => {
+  const nodes = [];
+  if (prefix > 0) {
+    nodes.push(symbol[0].repeat(prefix));
+  }
+  for (let i = 0; i < acc.length; ++i) {
+    nodes.push(...acc[i]);
+  }
+  if (postfix > 0) {
+    nodes.push(rest.slice(0, postfix));
+    rest = rest.slice(postfix);
+  }
+  return [nodes, rest];
+}): Parser<string | T> {
+  return input => {
+    const { source, context } = input;
+    assert(source.startsWith(symbol));
+    let acc: T[][] = [];
+    let i = symbol.length;
+    while (source[i] === source[0]) ++i;
+    let rest = source.slice(i);
+    let state = false;
+    for (; i >= symbol.length; i -= symbol.length) {
+      if (acc.length > 0 && rest.startsWith(symbol)) {
+        acc = [cons(acc.flat(), context)];
+        rest = rest.slice(symbol.length);
+        continue;
+      }
+      const result = parser({ source: rest, context });
+      if (result === undefined) break;
+      const nodes = eval(result);
+      rest = exec(result);
+      acc.push(nodes);
+      switch (nodes.at(-1)) {
+        case Command.Escape:
+          assert(!rest.startsWith(symbol));
+          nodes.pop();
+          state = false;
+          break;
+        case Command.Separator:
+          assert(!rest.startsWith(symbol));
+          nodes.pop();
+          state = true;
+          continue;
+        default:
+          acc = [cons(acc.flat(), context)];
+          state = true;
+          continue;
+      }
+      break;
+    }
+    if (acc.length === 0) return;
+    const prefix = i;
+    i = 0;
+    for (let len = min(prefix, rest.length); i < len && rest[i] === symbol[0];) {
+      ++i;
+    }
+    const postfix = i;
+    return termination(acc, rest, prefix, postfix, state);
+  };
+}
+
 export function markInvalid<T extends Element>(
   el: T,
   syntax: string,

package/src/parser/visibility.ts

@@ -45,36 +45,39 @@ function hasVisible(
 }
 
 export function blankWith(delimiter: string | RegExp): RegExp;
-export function blankWith(starting: '' | '\n', delimiter: string | RegExp): RegExp;
-export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): RegExp {
-  if (delimiter === undefined) return blankWith('', starting);
+export function blankWith(starts: '' | '\n', delimiter: string | RegExp): RegExp;
+export function blankWith(starts: '' | '\n', delimiter?: string | RegExp): RegExp {
+  if (delimiter === undefined) return blankWith('', starts);
   return new RegExp(String.raw
-    `^(?:(?=${
-      starting
-    })(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr[^\S\n]*>)${starting && '+'})?${
-      typeof delimiter === 'string' ? delimiter.replace(/[*+()\[\]]/g, '\\$&') : delimiter.source
+    `^(?:(?=${starts})(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr[^\S\n]*>)${
+      // 空行除去
+      starts && '+'
+    })?${
+      typeof delimiter === 'string'
+        ? delimiter.replace(/[*+()\[\]]/g, '\\$&')
+        : delimiter.source
     }`);
 }
 
-//export function startLoose<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
-//export function startLoose<T extends HTMLElement | string>(parser: Parser<T>, except?: string): Parser<T> {
+//export function looseStart<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
+//export function looseStart<T extends HTMLElement | string>(parser: Parser<T>, except?: string): Parser<T> {
 //  return input =>
-//    isStartLoose(input, except)
+//    isLooseStart(input, except)
 //      ? parser(input)
 //      : undefined;
 //}
-//const isStartLoose = reduce(({ source, context }: Input<MarkdownParser.Context>, except?: string): boolean => {
-//  return isStartTight({ source: source.replace(blank.start, ''), context }, except);
+//const isLooseStart = reduce(({ source, context }: Input<MarkdownParser.Context>, except?: string): boolean => {
+//  return isTightStart({ source: source.replace(blank.start, ''), context }, except);
 //}, ({ source }, except = '') => `${source}${Command.Separator}${except}`);
 
-export function startTight<P extends Parser<unknown>>(parser: P, except?: string): P;
-export function startTight<T>(parser: Parser<T>, except?: string): Parser<T> {
+export function tightStart<P extends Parser<unknown>>(parser: P, except?: string): P;
+export function tightStart<T>(parser: Parser<T>, except?: string): Parser<T> {
   return input =>
-    isStartTight(input, except)
+    isTightStart(input, except)
       ? parser(input)
       : undefined;
 }
-const isStartTight = reduce((input: Input<MarkdownParser.Context>, except?: string): boolean => {
+const isTightStart = reduce((input: Input<MarkdownParser.Context>, except?: string): boolean => {
   const { source } = input;
   if (source === '') return true;
   if (except && source.slice(0, except.length) === except) return false;
@@ -107,7 +110,7 @@ const isStartTight = reduce((input: Input<MarkdownParser.Context>, except?: stri
   }
 }, ({ source }, except = '') => `${source}${Command.Separator}${except}`);
 
-export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boolean {
+export function isLooseNodeStart(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;
   for (let i = 0; i < nodes.length; ++i) {
     const node = nodes[i];
@@ -116,11 +119,11 @@ export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boo
   }
   return false;
 }
-export function isStartTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
+export function isTightNodeStart(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;
   return isVisible(nodes[0], 0);
 }
-//export function isEndTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
+//export function isTightNodeEnd(nodes: readonly (HTMLElement | string)[]): boolean {
 //  if (nodes.length === 0) return true;
 //  return isVisible(nodes.at(-1)!, -1);
 //}