securemark 0.295.5 → 0.295.7

package/src/parser/block/sidefence.ts

@@ -21,7 +21,7 @@ const opener = /(?=\|\|+(?:$|[ \n]))/y;
 const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?: |(?=\|*(?:$|[ \n])))|\n$/g, '');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
-  some(recursion(Recursion.block, union([
+  recursion(Recursion.block, some(union([
     focus(
       /(?:\|\|+(?=$|[ \n])[^\n]*(?:$|\n))+/y,
       convert(unindent, source, true)),

package/src/parser/block/ulist.ts

@@ -15,7 +15,7 @@ export const ulist: UListParser = lazy(() => block(validate(
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
   /-(?=$|[ \n])/y,
-  some(recursion(Recursion.listitem, union([
+  recursion(Recursion.listitem, some(union([
     indexee(fmap(fallback(
       inits([
         line(open(/-(?:$|[ \n])/y, subsequence([

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

@@ -12,7 +12,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => rewrite(
     precedence(0, some(union([
       some(unescsource, /(?<![-+*=~^_,.;:!?]|\/{3})(?:[-+*=~^_,.;:!?]|\/{3,}(?!\/))*(?=[\\$"`\[\](){}<>（）［］｛｝|]|[^\x21-\x7E]|$)/y),
       precedence(1, verify(bracket, ns => ns.length > 0)),
-    ]), undefined, [[/[^\x21-\x7E]|\$/y, 9]])),
+    ]), [[/[^\x21-\x7E]|\$/y, 9]])),
     false,
     [3 | Backtrack.unescapable]),
   union([

package/src/parser/inline/deletion.ts

@@ -8,15 +8,14 @@ import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() =>
-  precedence(0, repeat('~~', surround(
+  precedence(0, recursion(Recursion.inline, repeat('~~', surround(
     '',
-    recursion(Recursion.inline,
     some(union([
       some(inline, blankWith('\n', '~~')),
       open('\n', some(inline, '~'), true),
-    ]))),
+    ])),
     '~~',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
-    nodes => new List([new Node(html('del', defrag(unwrap(nodes))))]))));
+    nodes => new List([new Node(html('del', defrag(unwrap(nodes))))])))));

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

@@ -11,7 +11,7 @@ describe('Unit: parser/inline/emphasis', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser, input('*', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('*a', new Context())), [['*', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a *', new Context())), [['*', 'a', ' ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a *', new Context())), [['*', 'a ', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a  *', new Context())), [['*', 'a', ' ', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a\n*', new Context())), [['*', 'a', '<br>', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a\\ *', new Context())), [['*', 'a', ' ', '*'], '']);

package/src/parser/inline/emphasis.ts

@@ -1,11 +1,11 @@
 import { EmphasisParser } from '../inline';
 import { Recursion } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -13,9 +13,8 @@ export const emphasis: EmphasisParser = lazy(() => surround(
   str(/\*(?!\*)/y),
   precedence(0, recursion(Recursion.inline,
   tightStart(some(union([
+    some(inline, '*', afterNonblank),
     strong,
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), inline),
   ]))))),
   str('*'),
   false, [],

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

@@ -11,7 +11,7 @@ describe('Unit: parser/inline/emstrong', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser, input('***', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('***a', new Context())), [['***a'], '']);
-      assert.deepStrictEqual(inspect(parser, input('***a ***', new Context())), [['***a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser, input('***a ***', new Context())), [['***a ', '***'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a  ***', new Context())), [['***a', ' ', '***'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a\n***', new Context())), [['***a', '<br>', '***'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a\\ ***', new Context())), [['***a', ' ', '***'], '']);
@@ -66,7 +66,7 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser, input('***a*\\ **b****', new Context())), [['<strong><em>a</em> <strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a*&Tab;**b****', new Context())), [['<strong><em>a</em>\t<strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a*<wbr>**b****', new Context())), [['<strong><em>a</em><wbr><strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('***a*b **', new Context())), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser, input('***a*b **', new Context())), [['**', '<em>a</em>', 'b ', '**'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a*b\\ **', new Context())), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a**b*', new Context())), [['<em><strong>a</strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a**b*c', new Context())), [['<em><strong>a</strong>b</em>'], 'c']);
@@ -77,7 +77,7 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser, input('***a**\\ *b**', new Context())), [['<em><strong>a</strong> <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a**&Tab;*b**', new Context())), [['<em><strong>a</strong>\t<em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a**<wbr>*b**', new Context())), [['<em><strong>a</strong><wbr><em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('***a**b *', new Context())), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser, input('***a**b *', new Context())), [['*', '<strong>a</strong>', 'b ', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a**b\\ *', new Context())), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a*', new Context())), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('***a**', new Context())), [['*', '<strong>a</strong>'], '']);
@@ -109,11 +109,11 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser, input('******a******', new Context())), [['<em><strong><em><strong>a</strong></em></strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('******a******b', new Context())), [['<em><strong><em><strong>a</strong></em></strong></em>'], 'b']);
       assert.deepStrictEqual(inspect(parser, input('******a*b', new Context())), [['*****', '<em>a</em>', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('******a*b *', new Context())), [['*****', '<em>a</em>', 'b', ' ', '*'], '']);
-      assert.deepStrictEqual(inspect(parser, input('******a*b **', new Context())), [['*****', '<em>a</em>', 'b', ' ', '**'], '']);
-      assert.deepStrictEqual(inspect(parser, input('******a*b ***', new Context())), [['*****', '<em>a</em>', 'b', ' ', '***'], '']);
-      assert.deepStrictEqual(inspect(parser, input('******a*b ****', new Context())), [['*****', '<em>a</em>', 'b', ' ', '****'], '']);
-      assert.deepStrictEqual(inspect(parser, input('******a*b *****', new Context())), [['*****', '<em>a</em>', 'b', ' ', '*****'], '']);
+      assert.deepStrictEqual(inspect(parser, input('******a*b *', new Context())), [['*****', '<em>a</em>', 'b ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser, input('******a*b **', new Context())), [['*****', '<em>a</em>', 'b ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser, input('******a*b ***', new Context())), [['*****', '<em>a</em>', 'b ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser, input('******a*b ****', new Context())), [['*****', '<em>a</em>', 'b ', '****'], '']);
+      assert.deepStrictEqual(inspect(parser, input('******a*b *****', new Context())), [['*****', '<em>a</em>', 'b ', '*****'], '']);
     });
 
   });

package/src/parser/inline/emstrong.ts

@@ -1,37 +1,31 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
 import { Parser, Result, List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, open, lazy, bind } from '../../combinator';
+import { union, some, recursion, precedence, surround, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const substrong: Parser.IntermediateParser<StrongParser> = lazy(() => some(union([
+  some(inline, '*', afterNonblank),
   emphasis,
-  some(inline, blankWith('*')),
-  open(some(inline, '*'), inline),
 ])));
 const subemphasis: Parser.IntermediateParser<EmphasisParser> = lazy(() => some(union([
+  some(inline, '*', afterNonblank),
   strong,
-  some(inline, blankWith('*')),
-  open(some(inline, '*'), inline),
 ])));
 
 // 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず
 // 可能な限り早く閉じるよう解析しなければならない。
 // このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
 export const emstrong: EmStrongParser = lazy(() =>
-  precedence(0, repeat('***', surround(
+  precedence(0, recursion(Recursion.inline, repeat('***', surround(
     '',
-    recursion(Recursion.inline,
-    tightStart(some(union([
-      some(inline, blankWith('*')),
-      open(some(inline, '*'), inline),
-    ])))),
+    tightStart(some(union([some(inline, '*', afterNonblank)]))),
     str(/\*{1,3}/y),
     false, [],
     ([, bs, cs], context): Result<Parser.Node<EmStrongParser>, Parser.Context<EmStrongParser>> => {
@@ -143,7 +137,7 @@ export const emstrong: EmStrongParser = lazy(() =>
         nodes = prepend('*'.repeat(prefix - postfix), nodes);
       }
       return nodes;
-    })));
+    }))));
 
 function prepend<N>(prefix: string, nodes: List<Node<N>>): List<Node<N>> {
   if (typeof nodes.head?.value === 'string') {

package/src/parser/inline/insertion.ts

@@ -8,15 +8,14 @@ import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() =>
-  precedence(0, repeat('++', surround(
+  precedence(0, recursion(Recursion.inline, repeat('++', surround(
     '',
-    recursion(Recursion.inline,
     some(union([
       some(inline, blankWith('\n', '++')),
       open('\n', some(inline, '+'), true),
-    ]))),
+    ])),
     '++',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
-    nodes => new List([new Node(html('ins', defrag(unwrap(nodes))))]))));
+    nodes => new List([new Node(html('ins', defrag(unwrap(nodes))))])))));

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

@@ -11,7 +11,7 @@ describe('Unit: parser/inline/italic', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser, input('///', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('///a', new Context())), [['///', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser, input('///a ///', new Context())), [['///', 'a', ' ', '///'], '']);
+      assert.deepStrictEqual(inspect(parser, input('///a ///', new Context())), [['///', 'a ', '///'], '']);
       assert.deepStrictEqual(inspect(parser, input('///a  ///', new Context())), [['///', 'a', ' ', '///'], '']);
       assert.deepStrictEqual(inspect(parser, input('///a\n///', new Context())), [['///', 'a', '<br>', '///'], '']);
       assert.deepStrictEqual(inspect(parser, input('///a\\ ///', new Context())), [['///', 'a', ' ', '///'], '']);

package/src/parser/inline/italic.ts

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

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

@@ -183,7 +183,7 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser, input('[@a]{b}', new Context())), [['<a class="link" href="b">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[@a@b]{c}', new Context())), [['<a class="link" href="c">@a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a@b]{c}', new Context())), [['<a class="link" href="c">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[==a==]{b}', new Context())), [['<a class="link" href="b">==a==</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[==a==]{b}', new Context())), [['<a class="link" href="b"><mark>a</mark></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[*a*]{b}', new Context())), [['<a class="link" href="b"><em>a</em></a>'], '']);
     });
 

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

@@ -14,7 +14,7 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser, input('==', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('==a', new Context())), [['==', 'a'], '']);
       assert.deepStrictEqual(inspect(parser, input('==a=', new Context())), [['==', 'a='], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a ==', new Context())), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a ==', new Context())), [['==', 'a ', '=='], '']);
       assert.deepStrictEqual(inspect(parser, input('==a  ==', new Context())), [['==', 'a', ' ', '=='], '']);
       assert.deepStrictEqual(inspect(parser, input('==a\n==', new Context())), [['==', 'a', '<br>', '=='], '']);
       assert.deepStrictEqual(inspect(parser, input('==a\\ ==', new Context())), [['==', 'a', ' ', '=='], '']);
@@ -38,12 +38,12 @@ describe('Unit: parser/inline/mark', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('==a ==b====', new Context())), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==- ==b====', new Context())), [['<mark id="mark::-_b">- <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::-_b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a\\ ==b====', new Context())), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a&Tab;==b====', new Context())), [['<mark id="mark::a_b=33Mw2l">a\t<mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b=33Mw2l"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a<wbr>==b====', new Context())), [['<mark id="mark::ab">a<wbr><mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::ab"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==*==a==*==', new Context())), [['<mark id="mark::a"><em><mark id="mark::a">a</mark><a href="#mark::a"></a></em></mark>', '<a href="#mark::a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a ==b====', new Context())), [['<mark id="mark::a_b">a <mark>b</mark></mark>', '<a href="#mark::a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==- ==b====', new Context())), [['<mark id="mark::-_b">- <mark>b</mark></mark>', '<a href="#mark::-_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a\\ ==b====', new Context())), [['<mark id="mark::a_b">a <mark>b</mark></mark>', '<a href="#mark::a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a&Tab;==b====', new Context())), [['<mark id="mark::a_b=33Mw2l">a\t<mark>b</mark></mark>', '<a href="#mark::a_b=33Mw2l"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a<wbr>==b====', new Context())), [['<mark id="mark::ab">a<wbr><mark>b</mark></mark>', '<a href="#mark::ab"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==*==a==*==', new Context())), [['<mark id="mark::a"><em><mark>a</mark></em></mark>', '<a href="#mark::a"></a>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -1,29 +1,26 @@
 import { MarkParser } from '../inline';
 import { State, Recursion, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, state, constraint, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, state, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap, repeat } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mark,
-  precedence(0, state(State.mark, repeat('==', surround(
+export const mark: MarkParser = lazy(() =>
+  precedence(0, recursion(Recursion.inline, repeat('==', surround(
     '',
-    recursion(Recursion.inline,
-    tightStart(some(union([
-      some(inline, blankWith('==')),
-      open(some(inline, '='), inline),
-    ])))),
+    tightStart(state(State.mark, some(union([inline]), '==', afterNonblank))),
     '==',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
-    (nodes, { id }) => {
+    (nodes, { id, state }) => {
       const el = html('mark', defrag(unwrap(nodes)));
+      if (state & State.linkers) return new List([new Node(el)]);
       define(el, { id: identity('mark', id, signature(el)) });
       return el.id
         ? new List([new Node(el), new Node(html('a', { href: `#${el.id}` }))])
         : new List([new Node(el)]);
-    })))));
+    }))));

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

@@ -109,6 +109,7 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser, input('$a$[A](a)', new Context())), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '[A](a)']);
       assert.deepStrictEqual(inspect(parser, input('$A$', new Context())), [['<span class="math" translate="no" data-src="$A$">$A$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$-a$', new Context())), [['<span class="math" translate="no" data-src="$-a$">$-a$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\ $', new Context())), [['<span class="math" translate="no" data-src="$\\ $">$\\ $</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$\\$$', new Context())), [['<span class="math" translate="no" data-src="$\\$$">$\\$$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$\\Pi$', new Context())), [['<span class="math" translate="no" data-src="$\\Pi$">$\\Pi$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$\\ 0$', new Context())), [['<span class="math" translate="no" data-src="$\\ 0$">$\\ 0$</span>'], '']);

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

@@ -30,8 +30,8 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser, input('[%% a [% b', new Context())), [['<span class="invalid">[%%</span>'], ' a [% b']);
       assert.deepStrictEqual(inspect(parser, input('[%\\ a %]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[% a\\ %]', new Context())), [['[%', ' a', ' ', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[% a%]', new Context())), [['[%', ' a', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[% a %%]', new Context())), [['[%', ' a %', '%', ']'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a%]', new Context())), [['[%', ' a%', ']'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[% a %%]', new Context())), [['[%', ' a %%', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('[% [%% %]', new Context())), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">[%%</span> %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[%% [% %%]', new Context())), [['<span class="invalid">[%%</span>'], ' [% %%]']);
       assert.deepStrictEqual(inspect(parser, input('[%% a %]', new Context())), [['<span class="invalid">[%%</span>'], ' a %]']);

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

@@ -11,7 +11,7 @@ describe('Unit: parser/inline/strong', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser, input('**', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('**a', new Context())), [['**', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser, input('**a **', new Context())), [['**', 'a', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser, input('**a **', new Context())), [['**', 'a ', '**'], '']);
       assert.deepStrictEqual(inspect(parser, input('**a  **', new Context())), [['**', 'a', ' ', '**'], '']);
       assert.deepStrictEqual(inspect(parser, input('**a\n**', new Context())), [['**', 'a', '<br>', '**'], '']);
       assert.deepStrictEqual(inspect(parser, input('**a\\ **', new Context())), [['**', 'a', ' ', '**'], '']);

package/src/parser/inline/strong.ts

@@ -1,11 +1,11 @@
 import { StrongParser } from '../inline';
 import { Recursion } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { tightStart, blankWith } from '../visibility';
+import { tightStart, afterNonblank } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -13,9 +13,8 @@ export const strong: StrongParser = lazy(() => surround(
   str(/\*\*(?!\*)/y),
   precedence(0, recursion(Recursion.inline,
   tightStart(some(union([
+    some(inline, '*', afterNonblank),
     emphasis,
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), inline),
   ]))))),
   str('**'),
   false, [],

package/src/parser/inline.test.ts

@@ -40,7 +40,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('*a***b****', new Context())), [['<em>a</em>', '<strong>b</strong>', '**'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a***b****c', new Context())), [['<em>a</em>', '<strong>b</strong>', '**', 'c'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a *b**', new Context())), [['<em>a <em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('*a *b**c', new Context())), [['*', 'a', ' ', '*', 'b', '**', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('*a *b**c', new Context())), [['*', 'a ', '*', 'b', '**', 'c'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a **b***', new Context())), [['<em>a <strong>b</strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a **b***c', new Context())), [['<em>a <strong>b</strong></em>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser, input('*a ***b****', new Context())), [['<em>a <em><strong>b</strong></em></em>'], '']);
@@ -101,8 +101,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('[$1]', new Context())), [['[', '$1', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('[$1-2]', new Context())), [['[', '$1-2', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('[$-1][$-2]', new Context())), [['<a class="label" data-label="$-1">$-1</a>', '<a class="label" data-label="$-2">$-2</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$-1, $-2', new Context())), [['<a class="label" data-label="$-1">$-1</a>', ',', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$-1 and $-2', new Context())), [['<a class="label" data-label="$-1">$-1</a>', ' and', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$-1, $-2', new Context())), [['<a class="label" data-label="$-1">$-1</a>', ', ', '<a class="label" data-label="$-2">$-2</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$-1 and $-2', new Context())), [['<a class="label" data-label="$-1">$-1</a>', ' and ', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$$-1', new Context())), [['$', '<a class="label" data-label="$-1">$-1</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[#a]]', new Context())), [['<sup class="reference"><span><a class="hashtag" href="/hashtags/a">#a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[$-1]]', new Context())), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
@@ -154,7 +154,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('[[a\nb]]', new Context())), [['[', '[', 'a', '<br>', 'b', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[a\nb]]]', new Context())), [['[', '[', '[', 'a', '<br>', 'b', ']', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('"[[""]]', new Context())), [['"', '[', '[', '"', '"', ']', ']'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[==a==]{b}', new Context())), [['<a class="link" href="b">==a==</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[==a==]{b}', new Context())), [['<a class="link" href="b"><mark>a</mark></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[a](b)]{c}', new Context())), [['<a class="link" href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[[[[[[{a}', new Context())), [['[', '[', '[', '[', '[', '[', '[', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('<http://host>', new Context())), [['<', '<a class="url" href="http://host" target="_blank">http://host</a>', '>'], '']);
@@ -170,6 +170,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('[#@a/http://host/(<bdi>)]</bdi>', new Context())), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/<span class="paren">(<span class="invalid">&lt;bdi&gt;</span>)</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[#a|<bdi>]</bdi>', new Context())), [['<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[#a|<bdi>]</bdi>', new Context())), [['[', '<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[*==*]{a}', new Context())), [['<a class="link" href="a">*==*</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[]{"}[[""]]}]', new Context())), [['<a class="url" href="&quot;">"</a>', '<sup class="reference"><span>""</span></sup>', '}', ']'], '']);
       assert.deepStrictEqual(inspect(parser, input('[ []{"}[[""]]}]', new Context())), [['[', ' ', '<a class="url" href="&quot;">"</a>', '<sup class="reference"><span>""</span></sup>', '}', ']'], '']);
     });

package/src/parser/source/escapable.ts

@@ -8,7 +8,7 @@ import { html } from 'typed-dom/dom';
 const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s\$|:\/\/)/g;
 
 export const escsource: EscapableSourceParser = ({ context }) => {
-  const { source, position } = context;
+  const { source, position, state } = context;
   if (position === source.length) return;
   const char = source[position];
   consume(1, context);
@@ -38,7 +38,7 @@ export const escsource: EscapableSourceParser = ({ context }) => {
     default:
       assert(char !== '\n');
       if (context.sequential) return new List([new Node(char)]);
-      let i = next(source, position, delimiter);
+      let i = next(source, position, state, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);

package/src/parser/source/text.ts

@@ -1,5 +1,5 @@
 import { TextParser, TxtParser } from '../source';
-import { Command } from '../context';
+import { State, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, consume } from '../../combinator';
 import { html } from 'typed-dom/dom';
@@ -9,7 +9,7 @@ export const nonWhitespace = /[^ \t　]/g;
 
 export const text: TextParser = input => {
   const { context } = input;
-  const { source, position } = context;
+  const { source, position, state } = context;
   if (position === source.length) return;
   const char = source[position];
   consume(1, context);
@@ -43,7 +43,7 @@ export const text: TextParser = input => {
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length
-        : next(source, position);
+        : next(source, position, state);
       assert(i > position);
       const lineend = 0
         || s && i === source.length
@@ -83,35 +83,28 @@ function isWhitespace(char: string, linebreak: boolean): boolean {
   }
 }
 
-export function next(source: string, position: number, delimiter?: RegExp): number {
+export function next(source: string, position: number, state: number, delimiter?: RegExp): number {
   let index: number;
   if (delimiter) {
     delimiter.lastIndex = position + 1;
     delimiter.test(source);
-    index = delimiter.lastIndex;
+    index = delimiter.lastIndex || position;
   }
   else {
-    index = seek(source, position);
+    index = seek(source, position, state);
   }
-  if (index === 0) return source.length;
+  if (index === position || index === source.length) return source.length;
   assert(index > position);
   const char = source[index];
   switch (char) {
-    case '$':
-    case '*':
-    case '+':
-    case '~':
-    case '=':
-    case '/':
-      index = backToWhitespace(source, position, index);
-      break;
     case '%':
-      index += index - 1 > position && source.startsWith(' %]', index - 1)
+      assert(source.startsWith('%]', index) && isWhitespace(source[index - 1], true) || delimiter);
+      index += !delimiter && index - 1 > position
         ? -1
         : 0;
       break;
     case '[':
-      index += index - 1 > position && source.startsWith(' [|', index - 1)
+      index += !delimiter && index - 1 > position && source.startsWith(' [|', index - 1)
         ? -1
         : 0;
       break;
@@ -121,19 +114,15 @@ export function next(source: string, position: number, delimiter?: RegExp): numb
         : index;
       break;
     case '@':
-      index = backToEmailHead(source, position, index);
+      index = ~state & State.autolink
+        ? backToEmailHead(source, position, index)
+        : index;
       break;
   }
   assert(index > position);
   return index;
 }
-export function backToWhitespace(source: string, position: number, index: number): number {
-  const prev = index - 1;
-  return prev > position && /\s/.test(source[prev])
-    ? prev
-    : index;
-}
-export function backToUrlHead(source: string, position: number, index: number): number {
+function backToUrlHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
   for (let i = index - 1; i >= position; --i) {
@@ -156,7 +145,7 @@ export function backToUrlHead(source: string, position: number, index: number):
     ? delim
     : index;
 }
-export function backToEmailHead(source: string, position: number, index: number): number {
+function backToEmailHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
   for (let i = index - 1; i >= position; --i) {
@@ -223,15 +212,13 @@ export function isAlphanumeric(char: string): boolean {
 //  }
 //};
 
-function seek(source: string, position: number): number {
+function seek(source: string, position: number, state: number): number {
   for (let i = position + 1; i < source.length; ++i) {
     const fst = source[i];
     //if (fst.charCodeAt(0) in dict) return i;
     switch (fst) {
       case '\\':
       case '!':
-      case '@':
-      case '#':
       case '$':
       case '"':
       case '`':
@@ -254,6 +241,10 @@ function seek(source: string, position: number): number {
       case '\r':
       case '\n':
         return i;
+      case '@':
+      case '#':
+        if (~state & State.autolink) return i;
+        continue;
       case '+':
       case '~':
       case '=':
@@ -263,7 +254,7 @@ function seek(source: string, position: number): number {
         if (source[i + 1] === fst && source[i + 2] === fst) return i;
         continue;
       case '%':
-        if (source[i + 1] === ']') return i;
+        if (source[i + 1] === ']' && isWhitespace(source[i - 1], true)) return i;
         continue;
       case ':':
         if (source[i + 1] === '/' && source[i + 2] === '/') return i;

package/src/parser/source/unescapable.ts

@@ -8,7 +8,7 @@ import { html } from 'typed-dom/dom';
 export const delimiter = /(?=(?=[\x00-\x7F])[^0-9A-Za-z]|(?<=[\x00-\x7F])[^\x00-\x7F])/g;
 
 export const unescsource: UnescapableSourceParser = ({ context }) => {
-  const { source, position } = context;
+  const { source, position, state } = context;
   if (position === source.length) return;
   const char = source[position];
   consume(1, context);
@@ -31,7 +31,7 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length
-        : next(source, position, delimiter);
+        : next(source, position, state, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);