securemark 0.291.0 → 0.292.0

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

@@ -1,58 +1,60 @@
 import { ruby } from './ruby';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/ruby', () => {
   describe('ruby', () => {
-    const parser = (source: string) => some(ruby)({ source, context: {} });
+    const parser = (source: string) => some(ruby)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('[(b)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[]()')), undefined);
-      assert.deepStrictEqual(inspect(parser('[](b)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[ ](b)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[ a](b)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[	a](b)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[	 a](b)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[&a;](b)')), [['<ruby>&amp;a;<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[a](&a;)')), [['<ruby>a<rp>(</rp><rt>&amp;a;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[<wbr>](a)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[a](<wbr>)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[a]()')), undefined);
-      assert.deepStrictEqual(inspect(parser('[a]( )')), undefined);
-      assert.deepStrictEqual(inspect(parser('[a\nb](c)')), undefined);
-      assert.deepStrictEqual(inspect(parser('[a](b\nc)')), undefined);
-      assert.deepStrictEqual(inspect(parser(' [a](b)')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[(b)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[]()'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[](b)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[ ](b)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[ a](b)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[&Tab;a](b)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[&Tab; a](b)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[&a;](b)'), ctx), [['<ruby>&amp;a;<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[a](&a;)'), ctx), [['<ruby>a<rp>(</rp><rt>&amp;a;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[<wbr>](a)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[a](<wbr>)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[a]()'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[a]( )'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[a\nb](c)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[a](b\nc)'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' [a](b)'), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('[A](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A](ab)')), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A](a b)')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A ](a b)')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A ](a b )')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A  ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp><rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A \\ ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp> <rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a)')), [['<ruby>AB<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a )')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB]( b)')), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](ab)')), [['<ruby>AB<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a b)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a b )')), [['<ruby>AB<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[AB](a b c)')), [['<ruby>AB<rp>(</rp><rt>a b c</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A B](ab)')), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[A B](a b)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[ABC]( b )')), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[ABC](a  c)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[東方](とう　ほう)')), [['<ruby>東<rp>(</rp><rt>とう</rt><rp>)</rp>方<rp>(</rp><rt>ほう</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[秦　\\　　こころ](はた　の　こころ)')), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>　<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[秦　&nbsp;　こころ](はた　の　こころ)')), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>&nbsp;<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[&&](&&)')), [['<ruby>&amp;&amp;<rp>(</rp><rt>&amp;&amp;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[&copy;](&copy;)')), [['<ruby>©<rp>(</rp><rt>©</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[&amp;copy;](&amp;copy;)')), [['<ruby>&amp;copy;<rp>(</rp><rt>&amp;copy;</rt><rp>)</rp></ruby>'], '']);
-      assert.deepStrictEqual(inspect(parser('[*A*](*a*)')), [['<ruby>*A*<rp>(</rp><rt>*a*</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A](ab)'), ctx), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A ](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A ](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A ](a b )'), ctx), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A  ](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp><rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A \\ ](a)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp> <rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[AB](a)'), ctx), [['<ruby>AB<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[AB](a )'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[AB]( b)'), ctx), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[AB](ab)'), ctx), [['<ruby>AB<rp>(</rp><rt>ab</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[AB](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[AB](a b )'), ctx), [['<ruby>AB<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[AB](a b c)'), ctx), [['<ruby>AB<rp>(</rp><rt>a b c</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A B](ab)'), ctx), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A B](a b)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[ABC]( b )'), ctx), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[ABC](a  c)'), ctx), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[東方](とう　ほう)'), ctx), [['<ruby>東<rp>(</rp><rt>とう</rt><rp>)</rp>方<rp>(</rp><rt>ほう</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[秦　\\　　こころ](はた　の　こころ)'), ctx), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>　<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[秦　&nbsp;　こころ](はた　の　こころ)'), ctx), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>&nbsp;<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[&&](&&)'), ctx), [['<ruby>&amp;&amp;<rp>(</rp><rt>&amp;&amp;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[&copy;](&copy;)'), ctx), [['<ruby>©<rp>(</rp><rt>©</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[&amp;copy;](&amp;copy;)'), ctx), [['<ruby>&amp;copy;<rp>(</rp><rt>&amp;copy;</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[*A*](*a*)'), ctx), [['<ruby>*A*<rp>(</rp><rt>*a*</rt><rp>)</rp></ruby>'], '']);
     });
 
   });

package/src/parser/inline/ruby.ts

@@ -1,9 +1,9 @@
 import { RubyParser } from '../inline';
 import { Backtrack } from '../context';
-import { eval, exec } from '../../combinator/data/parser';
+import { eval } from '../../combinator/data/parser';
 import { inits, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
-import { text } from '../source';
+import { txt } from '../source';
 import { isTightNodeStart } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
@@ -11,22 +11,22 @@ import { html, defrag } from 'typed-dom/dom';
 export const ruby: RubyParser = lazy(() => bind(
   inits([
     dup(surround(
-      '[', rtext, ']',
+      '[', text, ']',
       false,
-      ([, ns], rest) => {
+      ([, ns]) => {
         ns && ns.at(-1) === '' && ns.pop();
-        return isTightNodeStart(ns) ? [ns, rest] : undefined;
+        return isTightNodeStart(ns) ? [ns] : undefined;
       },
       undefined,
       [3 | Backtrack.ruby, 1 | Backtrack.bracket])),
     dup(surround(
-      '(', rtext, ')',
+      '(', text, ')',
       false, undefined, undefined,
       [3 | Backtrack.ruby, 1 | Backtrack.bracket])),
   ]),
-  ([texts, rubies], rest, context) => {
+  ([texts, rubies], context) => {
     if (rubies === undefined) {
-      const head = context.recent!.reduce((a, b) => a + b.length, rest.length);
+      const head = context.position - context.range!;
       return void setBacktrack(context, [2 | Backtrack.ruby], head);
     }
     switch (true) {
@@ -40,7 +40,7 @@ export const ruby: RubyParser = lazy(() => bind(
                   ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                   : [html('rt')]))
             , []))),
-        ], rest];
+        ]];
       case texts.length === 1 && [...texts[0]].length >= rubies.length:
         return [[
           html('ruby', defrag([...texts[0]]
@@ -51,52 +51,49 @@ export const ruby: RubyParser = lazy(() => bind(
                   ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                   : [html('rt')]))
             , []))),
-        ], rest];
+        ]];
       default:
         assert(rubies.length > 0);
         return [[
           html('ruby', defrag(unshift(
             [texts.join(' ')],
             [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]))),
-        ], rest];
+        ]];
     }
   }));
 
-const rtext: RubyParser.TextParser = ({ source, context }) => {
+const text: RubyParser.TextParser = input => {
+  const { context } = input;
+  const { source } = context;
   const acc = [''];
   let state = false;
-  while (source !== '') {
-    if (!/^(?:\\[^\n]|[^\\[\](){}<>"$#\n])/.test(source)) break;
-    assert(source[0] !== '\n');
-    switch (source[0]) {
-      // @ts-expect-error
+  for (let { position } = context; position < source.length; position = context.position) {
+    if (!/^(?:\\[^\n]|[^\\[\](){}<>"`$#:^|\n])/.test(source.slice(position, position + 2))) break;
+    assert(source[position] !== '\n');
+    switch (source[position]) {
       case '&': {
-        const result = unsafehtmlentity({ source, context });
-        if (result) {
-          acc[acc.length - 1] += eval(result)[0];
-          source = exec(result) ?? source.slice(1);
-          state ||= acc.at(-1)!.trimStart() !== '';
-          continue;
-        }
-        // fallthrough
+        const result = unsafehtmlentity(input) ?? txt(input)!;
+        assert(result);
+        acc[acc.length - 1] += eval(result)[0];
+        continue;
       }
       default: {
-        if (source[0].trimStart() === '') {
+        if (source[position].trimStart() === '') {
+          state ||= acc.at(-1)!.trimStart() !== '';
           acc.push('');
-          source = source.slice(1);
+          context.position += 1;
           continue;
         }
-        const result = text({ source, context })!;
+        const result = txt(input)!;
         assert(result);
-        acc[acc.length - 1] += eval(result)[0] ?? source.slice(0, source.length - exec(result).length);
-        source = exec(result);
-        state ||= acc.at(-1)!.trimStart() !== '';
+        acc[acc.length - 1] += eval(result)[0] ?? source.slice(position, context.position);
         continue;
       }
     }
   }
+  state ||= acc.at(-1)!.trimStart() !== '';
   return state
-    ? [acc, source]
+    ? [acc]
     : undefined;
 };
 

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

@@ -1,23 +1,25 @@
 import { shortmedia } from './shortmedia';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/shortmedia', () => {
   describe('shortmedia', () => {
-    const parser = (source: string) => some(shortmedia)({ source, context: {} });
+    const parser = (source: string) => some(shortmedia)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('!http')), undefined);
-      assert.deepStrictEqual(inspect(parser('!ttp')), undefined);
-      assert.deepStrictEqual(inspect(parser('!http://')), undefined);
-      assert.deepStrictEqual(inspect(parser('!Http://host')), undefined);
-      assert.deepStrictEqual(inspect(parser(' !http://host')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('!http'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('!ttp'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('!http://'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('!Http://host'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' !http://host'), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('!http://host')), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('!https://host')), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!http://host'), ctx), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!https://host'), ctx), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a>'], '']);
     });
 
   });

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

@@ -1,50 +1,54 @@
 import { strong } from './strong';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/strong', () => {
   describe('strong', () => {
-    const parser = (source: string) => some(strong)({ source, context: {} });
+    const parser = (source: string) => some(strong)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     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('**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('**a'), ctx), [['**', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('**a **'), ctx), [['**', 'a'], ' **']);
+      assert.deepStrictEqual(inspect(parser('**a  **'), ctx), [['**', 'a', ' '], ' **']);
+      assert.deepStrictEqual(inspect(parser('**a\n**'), ctx), [['**', 'a'], '\n**']);
+      assert.deepStrictEqual(inspect(parser('**a\\ **'), ctx), [['**', 'a'], '\\ **']);
+      assert.deepStrictEqual(inspect(parser('**a\\\n**'), ctx), [['**', 'a'], '\\\n**']);
+      assert.deepStrictEqual(inspect(parser('**a*'), ctx), [['**', 'a'], '*']);
+      assert.deepStrictEqual(inspect(parser('**a*b**'), ctx), [['**', 'a', '<em>b</em>'], '*']);
+      assert.deepStrictEqual(inspect(parser('** **'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('** a**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('** a **'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('**\n**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('**\na**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('**\\ a**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('**\\\na**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('**<wbr>a**'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('***a***'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' **a**'), ctx), 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<br>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a**'), ctx), [['<strong>a</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**ab**'), ctx), [['<strong>ab</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a\nb**'), ctx), [['<strong>a<br>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a\\\nb**'), ctx), [['<strong>a<br>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***'), ctx), [['<strong>a <em>b</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a **b****'), ctx), [['<strong>a <strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a&Tab;**b****'), ctx), [['<strong>a\t<strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a<wbr>**b****'), ctx), [['<strong>a<wbr><strong>b</strong></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*'), ctx), [['**', 'a', '<em>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c'), ctx), [['**', 'a', '<em>b</em>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c**'), ctx), [['<strong>a<em>b</em>c</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a*b*c**d'), ctx), [['<strong>a<em>b</em>c</strong>'], 'd']);
+      assert.deepStrictEqual(inspect(parser('**`a`**'), ctx), [['<strong><code data-src="`a`">a</code></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**(*a*)**'), ctx), [['<strong><span class="paren">(<em>a</em>)</span></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**(**a**)**'), ctx), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
     });
 
   });

package/src/parser/inline/strong.ts

@@ -3,6 +3,7 @@ import { Recursion } from '../context';
 import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
+import { emphasis } from './emphasis';
 import { str } from '../source';
 import { tightStart, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
@@ -12,12 +13,14 @@ export const strong: StrongParser = lazy(() => surround(
   str('**', '*'),
   precedence(0, recursion(Recursion.inline,
   tightStart(some(union([
-    some(inline, blankWith('**')),
+    emphasis,
+    some(inline, blankWith('*')),
     open(some(inline, '*'), union([
       emstrong,
       strong,
+      emphasis,
     ])),
   ]))))),
   str('**'), false,
-  ([, bs], rest) => [[html('strong', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]));
+  ([, bs]) => [[html('strong', defrag(bs))]],
+  ([as, bs]) => bs && [unshift(as, bs)]));

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

@@ -1,39 +1,41 @@
 import { template } from './template';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/template', () => {
   describe('template', () => {
-    const parser = (source: string) => some(template)({ source, context: {} });
+    const parser = (source: string) => some(template)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('{')), undefined);
-      assert.deepStrictEqual(inspect(parser('{}')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{\\}}')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{a}b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{{a}}')), undefined);
-      assert.deepStrictEqual(inspect(parser(' {{}}')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('{'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('{}'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('{{'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('{{\\}}'), ctx), [['<span class="invalid">{{\\}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser('{{a}b}'), ctx), [['<span class="invalid">{{a</span>'], '}b}']);
+      assert.deepStrictEqual(inspect(parser('{{{a}}'), ctx), [['<span class="invalid">{{{a}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser(' {{}}'), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('{{}}')), [['<span class="template">{{}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{}}}')), [['<span class="template">{{}}</span>'], '}']);
-      assert.deepStrictEqual(inspect(parser('{{ }}')), [['<span class="template">{{ }}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{ a }}')), [['<span class="template">{{ a }}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{\n}}')), [['<span class="template">{{<br>}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{\\\n}}')), [['<span class="template">{{\\<br>}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{a}}')), [['<span class="template">{{a}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{a b}}')), [['<span class="template">{{a b}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{\\}}}')), [['<span class="template">{{\\}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{<a>}}')), [['<span class="template">{{&lt;a&gt;}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{}}'), ctx), [['<span class="template">{{}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{}}}'), ctx), [['<span class="template">{{}}</span>'], '}']);
+      assert.deepStrictEqual(inspect(parser('{{ }}'), ctx), [['<span class="template">{{ }}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{ a }}'), ctx), [['<span class="template">{{ a }}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{\n}}'), ctx), [['<span class="template">{{<br>}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{\\\n}}'), ctx), [['<span class="template">{{\\<br>}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{a}}'), ctx), [['<span class="template">{{a}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{a b}}'), ctx), [['<span class="template">{{a b}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{\\}}}'), ctx), [['<span class="template">{{\\}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{<a>}}'), ctx), [['<span class="template">{{&lt;a&gt;}}</span>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('{{`a`}}')), [['<span class="template">{{`a`}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{{a}}}')), [['<span class="template">{{{a}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('{{{{a}}}}')), [['<span class="template">{{{{a}}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{`a`}}'), ctx), [['<span class="template">{{`a`}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{{a}}}'), ctx), [['<span class="template">{{{a}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{{{a}}}}'), ctx), [['<span class="template">{{{{a}}}}</span>'], '']);
     });
 
   });

package/src/parser/inline/template.ts

@@ -2,6 +2,7 @@ import { TemplateParser } from '../inline';
 import { Recursion, Backtrack } from '../context';
 import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
+import { invalid } from '../util';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -11,27 +12,35 @@ export const template: TemplateParser = lazy(() => surround(
   some(union([bracket, escsource]), '}')),
   str('}}'),
   true,
-  ([as, bs = [], cs], rest) =>
-    [[html('span', { class: 'template' }, defrag(push(unshift(as, bs), cs)))], rest],
-  undefined,
+  ([as, bs = [], cs]) =>
+    [[html('span', { class: 'template' }, defrag(push(unshift(as, bs), cs)))]],
+  ([, bs], context) =>
+    bs && [[
+      html('span',
+        {
+          class: 'invalid',
+          ...invalid('template', 'syntax', `Missing the closing symbol "}}"`),
+        },
+        context.source.slice(context.position - context.range!, context.position))
+    ]],
   [3 | Backtrack.doublebracket, 3 | Backtrack.escbracket]));
 
 const bracket: TemplateParser.BracketParser = lazy(() => union([
   surround(str('('), recursion(Recursion.terminal, some(union([bracket, escsource]), ')')), str(')'), true,
-    undefined, () => [[], ''], [3 | Backtrack.escbracket]),
+    undefined, () => [[]], [3 | Backtrack.escbracket]),
   surround(str('['), recursion(Recursion.terminal, some(union([bracket, escsource]), ']')), str(']'), true,
-    undefined, () => [[], ''], [3 | Backtrack.escbracket]),
+    undefined, () => [[]], [3 | Backtrack.escbracket]),
   surround(str('{'), recursion(Recursion.terminal, some(union([bracket, escsource]), '}')), str('}'), true,
-    undefined, () => [[], ''], [3 | Backtrack.escbracket]),
+    undefined, () => [[]], [3 | Backtrack.escbracket]),
   surround(
     str('"'),
     precedence(2, recursion(Recursion.terminal, some(escsource, '"', [['"', 2, false]]))),
     str('"'),
     true,
-    ([as, bs = [], cs], rest, { linebreak = 0 }) =>
-      linebreak > rest.length
-        ? [unshift(as, bs), cs[0] + rest]
-        : [push(unshift(as, bs), cs), rest],
-    ([as, bs = []], rest) => [unshift(as, bs), rest],
+    ([as, bs = [], cs], context) =>
+      context.linebreak === 0
+        ? [push(unshift(as, bs), cs)]
+        : (context.position -= 1, [unshift(as, bs)]),
+    ([as, bs]) => bs && [unshift(as, bs)],
     [3 | Backtrack.escbracket]),
 ]));