securemark 0.260.4 → 0.261.0

package/src/parser/inline/autolink.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../inline';
-import { union, some, syntax, constraint, validate, fmap } from '../../combinator';
+import { union, some, syntax, constraint, validate, focus, fmap } from '../../combinator';
 import { url } from './autolink/url';
 import { email } from './autolink/email';
 import { channel } from './autolink/channel';
@@ -14,22 +14,31 @@ import { stringify } from '../util';
 export const autolink: AutolinkParser = fmap(
   validate(/^(?:[@#>0-9a-z]|\S[#>])/i,
   constraint(State.autolink, false,
-  syntax(Syntax.autolink, 1, 1, State.none,
+  syntax(Syntax.autolink, 1, 1, ~State.shortcut,
   some(union([
     url,
     email,
     // Escape unmatched email-like strings.
-    str(/^[0-9a-z]+(?:[.+_-][0-9a-z]+)*(?:@(?:[0-9a-z]+(?:[.-][0-9a-z]+)*)?)*/i),
+    focus(
+      /^[0-9a-z](?:[_.+-](?=[0-9a-z])|[0-9a-z])*(?:@(?:[0-9a-z]+(?:[.-][0-9a-z]+)*)?)*/i,
+      ({ source }) => {
+        if (source.length > 255 || source.includes('@')) return [[source], ''];
+        const i = source.indexOf('_');
+        if (i === -1) return [[source], ''];
+        return [[source.slice(0, i)], source.slice(i)];
+      }),
     channel,
     account,
     // Escape unmatched account-like strings.
     str(/^@+[0-9a-z]*(?:-[0-9a-z]+)*/i),
     // Escape invalid leading characters.
-    str(new RegExp(/^(?:[^\p{C}\p{S}\p{P}\s]|emoji|['_])(?=#)/u.source.replace('emoji', emoji), 'u')),
+    str(new RegExp(/^(?:[^\p{C}\p{S}\p{P}\s]|emoji)(?=#)/u.source.replace('emoji', emoji), 'u')),
     hashtag,
     hashnum,
     // Escape unmatched hashtag-like strings.
-    str(new RegExp(/^#+(?:[^\p{C}\p{S}\p{P}\s]|emoji|['_])*/u.source.replace('emoji', emoji), 'u')),
+    str(new RegExp(/^#+(?:[^\p{C}\p{S}\p{P}\s]|emoji|')*/u.source.replace('emoji', emoji), 'u')),
+    // Escape invalid leading characters.
+    str(/^[0-9\p{Sc}](?=>)/u),
     anchor,
   ]))))),
   ns => ns.length === 1 ? ns : [stringify(ns)]);

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

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

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

@@ -7,47 +7,38 @@ describe('Unit: parser/inline/emphasis', () => {
     const parser = (source: string) => some(emphasis)({ 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('* *')), undefined);
-      assert.deepStrictEqual(inspect(parser('* a*')), undefined);
-      assert.deepStrictEqual(inspect(parser('* a *')), undefined);
-      assert.deepStrictEqual(inspect(parser('*\n*')), undefined);
-      assert.deepStrictEqual(inspect(parser('*\na*')), undefined);
-      assert.deepStrictEqual(inspect(parser('*\\ a*')), undefined);
-      assert.deepStrictEqual(inspect(parser('*\\\na*')), undefined);
-      assert.deepStrictEqual(inspect(parser('*<wbr>a*')), undefined);
-      assert.deepStrictEqual(inspect(parser('**a**')), undefined);
-      assert.deepStrictEqual(inspect(parser('***a***')), undefined);
-      assert.deepStrictEqual(inspect(parser(' *a*')), undefined);
+      assert.deepStrictEqual(inspect(parser('_')), 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*')), [['<em>a</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*ab*')), [['<em>ab</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['<em>a<br>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['<em>a<span class="linebreak"> </span>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**')), [['<em>a</em>'], '*']);
+      assert.deepStrictEqual(inspect(parser('_a_')), [['<em>a</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_ab_')), [['<em>ab</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a\nb_')), [['<em>a<br>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a\\\nb_')), [['<em>a<span class="linebreak"> </span>b</em>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('*a *b**')), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a **b***')), [['<em>a <strong>b</strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\\ *b**')), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a&Tab;*b**')), [['<em>a\t<em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a<wbr>*b**')), [['<em>a<wbr><em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b**c*')), [['<em>a<strong>b</strong>c</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a**b**c*d')), [['<em>a<strong>b</strong>c</em>'], 'd']);
-      assert.deepStrictEqual(inspect(parser('*`a`*')), [['<em><code data-src="`a`">a</code></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*(*a*)*')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*(**a**)*')), [['<em><span class="paren">(<strong>a</strong>)</span></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a _b__')), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a *b*_')), [['<em>a <strong>b</strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a\\ _b__')), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a&Tab;_b__')), [['<em>a\t<em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_a<wbr>_b__')), [['<em>a<wbr><em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('_(_a_)_')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
     });
 
   });

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/escape.ts

@@ -6,20 +6,11 @@ import { str } from '../source';
 const repeat = str(/^(.)\1*/);
 
 export const escape: EscapeParser = union([({ source, context }) => {
-  if (source.length < 3) return;
   switch (source[0]) {
-    case '*':
-      if (source.length < 4) return;
-      assert(source[3]);
-      return source[3] === source[0]
-          && source[2] === source[0]
-          && source[1] === source[0]
-        ? repeat({ source, context })
-        : undefined;
     case '+':
     case '~':
     case '=':
-      assert(source[2]);
+      if (!source[2]) return;
       return source[2] === source[0]
           && source[1] === source[0]
         ? repeat({ source, context })

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/extension/index.ts

@@ -13,7 +13,7 @@ import IndexParser = ExtensionParser.IndexParser;
 export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surround(
   '[#',
   constraint(State.index, false,
-  syntax(Syntax.index, 2, 1, State.linkable,
+  syntax(Syntax.index, 2, 1, State.linkers | State.media,
   startTight(
   open(stropt(/^\|?/), trimBlankEnd(some(union([
     signature,

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/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/link.ts

@@ -25,7 +25,7 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], union([
 
 const textlink: LinkParser.TextLinkParser = lazy(() =>
   constraint(State.link, false,
-  syntax(Syntax.link, 2, 10, State.linkable,
+  syntax(Syntax.link, 2, 10, State.linkers | State.media,
   bind(reverse(tails([
     dup(surround(
       '[',
@@ -41,7 +41,7 @@ const textlink: LinkParser.TextLinkParser = lazy(() =>
 
 const medialink: LinkParser.MediaLinkParser = lazy(() =>
   constraint(State.link | State.media, false,
-  syntax(Syntax.link, 2, 10, State.linkable ^ State.media,
+  syntax(Syntax.link, 2, 10, State.linkers,
   bind(reverse(sequence([
     dup(surround(
       '[',

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/media.ts

@@ -21,7 +21,7 @@ Object.setPrototypeOf(optspec, null);
 export const media: MediaParser = lazy(() => validate(['![', '!{'], open(
   '!',
   constraint(State.media, false,
-  syntax(Syntax.media, 2, 10, State.none,
+  syntax(Syntax.media, 2, 10, ~State.link,
   bind(verify(fmap(tails([
     dup(surround(
       '[',
@@ -55,7 +55,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], open(
       el.style.aspectRatio = el.getAttribute('aspect-ratio')!;
     }
     if (context.state! & State.link) return [[el], rest];
-    if (cache && cache.tagName !== 'IMG') return creation(10, (..._) => [[el!], rest])({ source: '!', context });
+    if (cache && cache.tagName !== 'IMG') return creation(10, _ => [[el!], rest])({ source: '!', context });
     return fmap(
       unsafelink as MediaParser,
       ([link]) => [define(link, { class: null, target: '_blank' }, [el])])

package/src/parser/inline/ruby.ts

@@ -1,20 +1,24 @@
 import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, syntax, creation, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
+import { sequence, syntax, creation, validate, verify, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
-import { text as txt } from '../source';
+import { text as txt, str } from '../source';
 import { Syntax, State } from '../context';
 import { isStartTightNodes } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
-export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.none, 2, 1, State.none, fmap(verify(
+export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.ruby, 2, 1, State.all, fmap(verify(fmap(
   sequence([
-    surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
-    surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),
+    surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']'),
+    surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')'),
   ]),
-  ([texts]) => isStartTightNodes(texts)),
+  ([texts, rubies], _, context) => [
+    eval(text({ source: texts, context }), [])[0] ?? '',
+    eval(text({ source: rubies, context }), [])[0] ?? '',
+  ]),
+  ([texts, rubies]) => texts && rubies && isStartTightNodes(texts)),
   ([texts, rubies]) => {
     texts[texts.length - 1] === '' && texts.pop();
     switch (true) {

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,
-    ])),
+    some(inline, blankWith('*')),
+    open(some(inline, '*'), strong),
   ])), '*')),
-  str('**'), false,
+  str('*'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/template.ts

@@ -7,7 +7,7 @@ import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const template: TemplateParser = lazy(() => surround(
-  '{{', syntax(Syntax.none, 2, 1, State.none, some(union([bracket, escsource]), '}')), '}}', true,
+  '{{', syntax(Syntax.none, 2, 1, State.all, some(union([bracket, escsource]), '}')), '}}', true,
   ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest]));
 
 const bracket: TemplateParser.BracketParser = lazy(() => creation(union([