securemark 0.299.4 → 0.300.0

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { LinkParser } from '../inline';
-import { Context, State, Backtrack, Command } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { union, inits, sequence, subsequence, some, spend, precedence, state, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { Input, State, Backtrack, Command } from '../context';
+import { List, Node } from '../../combinator/parser';
+import { union, inits, sequence, subsequence, some, precedence, state, constraint, backtrack, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { str } from '../source';
@@ -15,42 +15,42 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
+export const textlink: LinkParser.TextLinkParser = lazy(() => backtrack(bind(
   subsequence([
-    constraint(State.link, state(State.linkers, dup(surround(
+    constraint(State.link, state(State.linkers, backtrack(dup(surround(
       open('[', beforeNonblank),
       precedence(1,
       some(union([inline]), ']', [[']', 1]])),
       ']',
       true,
       [3 | Backtrack.common | Backtrack.link, 2 | Backtrack.ruby],
-      ([, ns = new List()], context) => {
-        if (context.linebreak !== 0) {
-          const head = context.position - context.range;
-          return void setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head);
+      ([, ns = new List()], input, output) => {
+        if (input.linebreak !== 0) {
+          const head = input.position - input.range;
+          return void setBacktrack(input, 2 | Backtrack.link | Backtrack.ruby, head);
         }
-        return ns.push(new Node(Command.Separator)) && ns;
-      })))),
+        return output.import(ns.push(new Node(Command.Separator)));
+      }))))),
     // `{ `と`{`で個別にバックトラックが発生し+1nされる。
     // 自己再帰的にパースしてもオプションの不要なパースによる計算量の増加により相殺される。
-    dup(surround(
+    backtrack(dup(surround(
       /{(?![{}])/y,
       inits([uri, some(option)]),
       / ?}/y,
       false, [],
       undefined,
-      ([as, bs]) =>
-        bs && as.import(bs).push(new Node(Command.Cancel)) && as)),
+      ([as, bs], _, output) =>
+        bs && output.import(as.import(bs).push(new Node(Command.Cancel)))))),
   ]),
-  ([{ value: content }, { value: params = undefined } = {}], context) => {
-    if (context.state & State.link) return new List([
-      new Node(context.source.slice(context.position - context.range, context.position).replace(/\\($|.)/g, '$1'))
+  ([{ value: content }, { value: params = undefined } = {}], input) => {
+    if (input.state & State.link) return new List([
+      new Node(input.source.slice(input.position - input.range, input.position).replace(/\\($|.)/g, '$1'))
     ]);
     if (content.last!.value === Command.Separator) {
       content.pop();
       if (params === undefined) {
-        const head = context.position - context.range;
-        return void setBacktrack(context, 2 | Backtrack.link, head);
+        const head = input.position - input.range;
+        return void setBacktrack(input, 2 | Backtrack.link, head);
       }
     }
     else {
@@ -65,18 +65,18 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
             class: 'invalid',
             ...invalid('link', 'syntax', 'Missing the closing symbol "}"')
           },
-          context.source.slice(context.position - context.range, context.position)))
+          input.source.slice(input.position - input.range, input.position)))
       ]);
     }
     assert(!html('div', unwrap(content)).querySelector('a, .media, .annotation, .reference'));
     assert(content.head?.value !== '');
     if (content.length !== 0 && trimBlankNodeEnd(content).length === 0) return;
-    return new List([new Node(parse(content, params as List<Node<string>>, context))]);
-  }));
+    return new List([new Node(parse(content, params as List<Node<string>>, input))]);
+  })));
 
 export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media,
   state(State.linkers,
-  bind(sequence([
+  backtrack(bind(sequence([
     dup(surround(
       '[',
       union([media, shortmedia]),
@@ -86,8 +86,8 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State
       inits([uri, some(option)]),
       / ?}/y)),
   ]),
-  ([{ value: content }, { value: params }], context) =>
-    new List([new Node(parse(content, params as List<Node<string>>, context))])))));
+  ([{ value: content }, { value: params }], input) =>
+    new List([new Node(parse(content, params as List<Node<string>>, input))]))))));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
   open(' ', str(/\S+/y)),
@@ -103,18 +103,17 @@ export const option: LinkParser.ParameterParser.OptionParser = union([
 export function parse(
   content: List<Node<string | HTMLElement>>,
   params: List<Node<string>>,
-  context: Context,
+  input: Input,
 ): HTMLAnchorElement {
   assert(params.length > 0);
   const INSECURE_URI = params.shift()!.value;
   assert(INSECURE_URI === INSECURE_URI.trim());
   assert(!INSECURE_URI.match(/\s/));
-  spend(context, 10);
   let uri: ReadonlyURL | undefined;
   try{
     uri = new ReadonlyURL(
-      resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
-      context.host?.href || location.href);
+      resolve(INSECURE_URI, input.host ?? location, input.url ?? input.host ?? location),
+      input.host?.href || location.href);
   }
   catch {
   }
@@ -122,7 +121,7 @@ export function parse(
     INSECURE_URI,
     content,
     uri,
-    context.host?.origin || location.origin);
+    input.host?.origin || location.origin);
   return el.classList.contains('invalid')
     ? el
     : define(el, attributes('link', optspec, unwrap(params))[0]);

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

@@ -1,7 +1,6 @@
 import { mark } from './mark';
 import { some } from '../../combinator';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/mark', () => {
@@ -9,42 +8,42 @@ describe('Unit: parser/inline/mark', () => {
     const parser = some(mark);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('=', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('==', new Context())), [['=='], '']);
-      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', ' ', '=='], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a\\\n==', new Context())), [['==', 'a', '<br>', '=='], '']);
-      assert.deepStrictEqual(inspect(parser, input('== ==', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('== a==', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('== a ==', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('==\na==', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('==\\\na==', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('==<wbr>a==', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input(' ==a==', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('=')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('==')), [['=='], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a')), [['==', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a=')), [['==', 'a='], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a ==')), [['==', 'a ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a  ==')), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a\n==')), [['==', 'a', '<br>', '=='], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a\\ ==')), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a\\\n==')), [['==', 'a', '<br>', '=='], '']);
+      assert.deepStrictEqual(inspect(parser, input('== ==')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('== a==')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('== a ==')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('==\na==')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('==\\\na==')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('==<wbr>a==')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ==a==')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('==a==', new Context())), [['<mark id="mark::a">a</mark>', '<a href="#mark::a"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a=b==', new Context())), [['<mark id="mark::a=b=3lYfIw">a=b</mark>', '<a href="#mark::a=b=3lYfIw"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==\\===', new Context())), [['<mark id="mark::=">=</mark>', '<a href="#mark::="></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a===', new Context())), [['<mark id="mark::a">a</mark>', '<a href="#mark::a"></a>'], '=']);
-      assert.deepStrictEqual(inspect(parser, input('==a\nb==', new Context())), [['<mark id="mark::a_b=12Ta86">a<br>b</mark>', '<a href="#mark::a_b=12Ta86"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('==a\\\nb==', new Context())), [['<mark id="mark::a_b=12Ta86">a<br>b</mark>', '<a href="#mark::a_b=12Ta86"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a==')), [['<mark id="mark::a">a</mark>', '<a href="#mark::a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a=b==')), [['<mark id="mark::a=b=3lYfIw">a=b</mark>', '<a href="#mark::a=b=3lYfIw"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==\\===')), [['<mark id="mark::=">=</mark>', '<a href="#mark::="></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a===')), [['<mark id="mark::a">a</mark>', '<a href="#mark::a"></a>'], '=']);
+      assert.deepStrictEqual(inspect(parser, input('==a\nb==')), [['<mark id="mark::a_b=12Ta86">a<br>b</mark>', '<a href="#mark::a_b=12Ta86"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a\\\nb==')), [['<mark id="mark::a_b=12Ta86">a<br>b</mark>', '<a href="#mark::a_b=12Ta86"></a>'], '']);
     });
 
     it('nest', () => {
-      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>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('====a== b==', new Context())), [['<mark id="mark::a_b"><mark>a</mark> b</mark>', '<a href="#mark::a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a ==b====')), [['<mark id="mark::a_b">a <mark>b</mark></mark>', '<a href="#mark::a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==- ==b====')), [['<mark id="mark::-_b">- <mark>b</mark></mark>', '<a href="#mark::-_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a\\ ==b====')), [['<mark id="mark::a_b">a <mark>b</mark></mark>', '<a href="#mark::a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==a&Tab;==b====')), [['<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====')), [['<mark id="mark::ab">a<wbr><mark>b</mark></mark>', '<a href="#mark::ab"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('==*==a==*==')), [['<mark id="mark::a"><em><mark>a</mark></em></mark>', '<a href="#mark::a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('====a== b==')), [['<mark id="mark::a_b"><mark>a</mark> b</mark>', '<a href="#mark::a_b"></a>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -1,7 +1,7 @@
 import { MarkParser } from '../inline';
 import { State, Recursion, Command } from '../context';
-import { List, Node } from '../../combinator/data/parser';
-import { union, some, precedence, state, surround, lazy } from '../../combinator';
+import { List, Node } from '../../combinator/parser';
+import { union, some, precedence, state, backtrack, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
 import { repeat } from '../repeat';
@@ -10,14 +10,14 @@ import { unwrap } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() =>
-  repeat('==', beforeNonblank, '==', Recursion.inline, precedence(0, surround(
+  repeat('==', beforeNonblank, '==', Recursion.inline, precedence(0, backtrack(surround(
     '',
     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, state }, lead) => {
+    ([, bs], _, output) => output.import(bs),
+    ([, bs], _, output) => bs && output.import(bs.push(new Node(Command.Cancel)))))),
+    (nodes, { id, state }, _, lead) => {
       const el = html('mark', defrag(unwrap(nodes)));
       if (state & State.linkers || lead >= 2) return new List([new Node(el)]);
       define(el, { id: identity('mark', id, signature(el.cloneNode(true))) });

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

@@ -1,7 +1,6 @@
 import { math } from './math';
 import { some } from '../../combinator';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/math', () => {
@@ -9,153 +8,153 @@ describe('Unit: parser/inline/math', () => {
     const parser = some(math);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$$$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$0 $', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$0\\ $', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$0\\\n$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-0, $-1', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-0 and $-1', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-0と$-1', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a $-b', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a\\ $-b', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a $', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a `$`', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a ``$``', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$$$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$0 $')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$0\\ $')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$0\\\n$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-0, $-1')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-0 and $-1')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-0と$-1')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a $-b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a\\ $-b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a $')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a `$`')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a ``$``')), undefined);
       // (``" + ``" + $-b") or (``"`` + "$-b")
-      assert.deepStrictEqual(inspect(parser, input('$-a ``"``"$-b"', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a ``"``"$-b"')), undefined);
       // (``b`` + "c" + $-d) or (``b``"c" + $-d)
-      assert.deepStrictEqual(inspect(parser, input('$-a ``b``"c"$-d', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a"$-b"', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a\\"$-b\\"', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a($-b)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a\\($-b\\)', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a[$-b]', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a\\[$-b\\]', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$-a{$-b}', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a{$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a$b', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a$b$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$ $', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$\\ $', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$ a$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$ a $', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$\n$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$\\\n$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a\nb$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a\\\nb$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a\\$\nb$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$a\\$\\\nb$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$`$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$`a"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$`a"b$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``$"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a"$0', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a""b$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a""$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$```a"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$```a""$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``\n"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a\\$\nb"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a\\$\\\nb"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``\\"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$``a``b"c"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$````""$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$"$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${}', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a} $', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a{b}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a}b}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a}b$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a}b{c}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a}{b}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${\\}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${\n}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${\\\n}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a\nb}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a\\\nb}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${$}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a\\$\nb}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${a\\$\\\nb}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('$\\begin$', new Context())), [['<span class="invalid" translate="no">$\\begin$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$\\huge0$', new Context())), [['<span class="invalid" translate="no">$\\huge0$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$\\Begin$', new Context())), [['<span class="invalid" translate="no">$\\Begin$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$\\begin{}$', new Context())), [['<span class="invalid" translate="no">$\\begin{}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('${\\begin}$', new Context())), [['<span class="invalid" translate="no">${\\begin}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$http://host$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('${http://host}$', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input(' ${a}$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a ``b``"c"$-d')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a"$-b"')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a\\"$-b\\"')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a($-b)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a\\($-b\\)')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a[$-b]')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a\\[$-b\\]')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$-a{$-b}')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a{$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a$b')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a$b$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$ $')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$\\ $')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$ a$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$ a $')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$\n$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$\\\n$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a\nb$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a\\\nb$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a\\$\nb$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$a\\$\\\nb$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$`$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$`a"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$`a"b$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``$"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a"$0')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a""b$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a""$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$```a"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$```a""$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``\n"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a\\$\nb"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a\\$\\\nb"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``\\"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$``a``b"c"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$````""$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$"$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${}')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a} $')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a{b}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a}b}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a}b$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a}b{c}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a}{b}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${\\}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${\n}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${\\\n}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a\nb}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a\\\nb}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${$}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a\\$\nb}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${a\\$\\\nb}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('$\\begin$')), [['<span class="invalid" translate="no">$\\begin$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\huge0$')), [['<span class="invalid" translate="no">$\\huge0$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\Begin$')), [['<span class="invalid" translate="no">$\\Begin$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\begin{}$')), [['<span class="invalid" translate="no">$\\begin{}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${\\begin}$')), [['<span class="invalid" translate="no">${\\begin}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$http://host$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${http://host}$')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ${a}$')), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('$0$', new Context())), [['<span class="math" translate="no" data-src="$0$">$0$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$0$$', new Context())), [['<span class="math" translate="no" data-src="$0$">$0$</span>'], '$']);
-      assert.deepStrictEqual(inspect(parser, input('$00$', new Context())), [['<span class="math" translate="no" data-src="$00$">$00$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$-0$', new Context())), [['<span class="math" translate="no" data-src="$-0$">$-0$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$0-1$', new Context())), [['<span class="math" translate="no" data-src="$0-1$">$0-1$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$0+1$', new Context())), [['<span class="math" translate="no" data-src="$0+1$">$0+1$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$0*1$', new Context())), [['<span class="math" translate="no" data-src="$0*1$">$0*1$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$0/1$', new Context())), [['<span class="math" translate="no" data-src="$0/1$">$0/1$</span>'], '']);
-      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('$a-b$', new Context())), [['<span class="math" translate="no" data-src="$a-b$">$a-b$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$a+b$', new Context())), [['<span class="math" translate="no" data-src="$a+b$">$a+b$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$a*b$', new Context())), [['<span class="math" translate="no" data-src="$a*b$">$a*b$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$a/b$', new Context())), [['<span class="math" translate="no" data-src="$a/b$">$a/b$</span>'], '']);
-      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('$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('$\\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>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$\\\\0$', new Context())), [['<span class="math" translate="no" data-src="$\\\\0$">$\\\\0$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$|1|$', new Context())), [['<span class="math" translate="no" data-src="$|1|$">$|1|$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$[0,1)$]', new Context())), [['<span class="math" translate="no" data-src="$[0,1)$">$[0,1)$</span>'], ']']);
-      assert.deepStrictEqual(inspect(parser, input('$(0, 1]$)', new Context())), [['<span class="math" translate="no" data-src="$(0, 1]$">$(0, 1]$</span>'], ')']);
-      assert.deepStrictEqual(inspect(parser, input('$\\{0,1\\}$', new Context())), [['<span class="math" translate="no" data-src="$\\{0,1\\}$">$\\{0,1\\}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$n=1$', new Context())), [['<span class="math" translate="no" data-src="$n=1$">$n=1$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$n<m$', new Context())), [['<span class="math" translate="no" data-src="$n&lt;m$">$n&lt;m$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$n>m$', new Context())), [['<span class="math" translate="no" data-src="$n&gt;m$">$n&gt;m$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$E = mc^2$', new Context())), [['<span class="math" translate="no" data-src="$E = mc^2$">$E = mc^2$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$f(x)$', new Context())), [['<span class="math" translate="no" data-src="$f(x)$">$f(x)$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$f: x \\to y$', new Context())), [['<span class="math" translate="no" data-src="$f: x \\to y$">$f: x \\to y$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$k$\\-space', new Context())), [['<span class="math" translate="no" data-src="$k$">$k$</span>'], '\\-space']);
-      assert.deepStrictEqual(inspect(parser, input('$a{b}$', new Context())), [['<span class="math" translate="no" data-src="$a{b}$">$a{b}$</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('${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('${a}$0', new Context())), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '0']);
-      assert.deepStrictEqual(inspect(parser, input('${a}$b', new Context())), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], 'b']);
-      assert.deepStrictEqual(inspect(parser, input('${ab}$', new Context())), [['<span class="math" translate="no" data-src="${ab}$">${ab}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('${a b}$', new Context())), [['<span class="math" translate="no" data-src="${a b}$">${a b}$</span>'], '']);
-      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('${ 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="${``&quot;}$">${``"}$</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('${あ}$', new Context())), [['<span class="math" translate="no" data-src="${あ}$">${あ}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$0$')), [['<span class="math" translate="no" data-src="$0$">$0$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$0$$')), [['<span class="math" translate="no" data-src="$0$">$0$</span>'], '$']);
+      assert.deepStrictEqual(inspect(parser, input('$00$')), [['<span class="math" translate="no" data-src="$00$">$00$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$-0$')), [['<span class="math" translate="no" data-src="$-0$">$-0$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$0-1$')), [['<span class="math" translate="no" data-src="$0-1$">$0-1$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$0+1$')), [['<span class="math" translate="no" data-src="$0+1$">$0+1$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$0*1$')), [['<span class="math" translate="no" data-src="$0*1$">$0*1$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$0/1$')), [['<span class="math" translate="no" data-src="$0/1$">$0/1$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$a$')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$a$$')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '$']);
+      assert.deepStrictEqual(inspect(parser, input('$a-b$')), [['<span class="math" translate="no" data-src="$a-b$">$a-b$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$a+b$')), [['<span class="math" translate="no" data-src="$a+b$">$a+b$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$a*b$')), [['<span class="math" translate="no" data-src="$a*b$">$a*b$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$a/b$')), [['<span class="math" translate="no" data-src="$a/b$">$a/b$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`$a'$`)), [[`<span class="math" translate="no" data-src="$a'$">$a'$</span>`], '']);
+      assert.deepStrictEqual(inspect(parser, input(`$a''$`)), [[`<span class="math" translate="no" data-src="$a''$">$a''$</span>`], '']);
+      assert.deepStrictEqual(inspect(parser, input('$a$[A](a)')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '[A](a)']);
+      assert.deepStrictEqual(inspect(parser, input('$A$')), [['<span class="math" translate="no" data-src="$A$">$A$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$-a$')), [['<span class="math" translate="no" data-src="$-a$">$-a$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\$$')), [['<span class="math" translate="no" data-src="$\\$$">$\\$$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\Pi$')), [['<span class="math" translate="no" data-src="$\\Pi$">$\\Pi$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\ 0$')), [['<span class="math" translate="no" data-src="$\\ 0$">$\\ 0$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$\\\\0$')), [['<span class="math" translate="no" data-src="$\\\\0$">$\\\\0$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$|1|$')), [['<span class="math" translate="no" data-src="$|1|$">$|1|$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$[0,1)$]')), [['<span class="math" translate="no" data-src="$[0,1)$">$[0,1)$</span>'], ']']);
+      assert.deepStrictEqual(inspect(parser, input('$(0, 1]$)')), [['<span class="math" translate="no" data-src="$(0, 1]$">$(0, 1]$</span>'], ')']);
+      assert.deepStrictEqual(inspect(parser, input('$\\{0,1\\}$')), [['<span class="math" translate="no" data-src="$\\{0,1\\}$">$\\{0,1\\}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$n=1$')), [['<span class="math" translate="no" data-src="$n=1$">$n=1$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$n<m$')), [['<span class="math" translate="no" data-src="$n&lt;m$">$n&lt;m$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$n>m$')), [['<span class="math" translate="no" data-src="$n&gt;m$">$n&gt;m$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$E = mc^2$')), [['<span class="math" translate="no" data-src="$E = mc^2$">$E = mc^2$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$f(x)$')), [['<span class="math" translate="no" data-src="$f(x)$">$f(x)$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$f: x \\to y$')), [['<span class="math" translate="no" data-src="$f: x \\to y$">$f: x \\to y$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$k$\\-space')), [['<span class="math" translate="no" data-src="$k$">$k$</span>'], '\\-space']);
+      assert.deepStrictEqual(inspect(parser, input('$a{b}$')), [['<span class="math" translate="no" data-src="$a{b}$">$a{b}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$a\\{$\\}')), [['<span class="math" translate="no" data-src="$a\\{$">$a\\{$</span>'], '\\}']);
+      assert.deepStrictEqual(inspect(parser, input('${}$')), [['<span class="math" translate="no" data-src="${}$">${}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${ }$')), [['<span class="math" translate="no" data-src="${ }$">${ }$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${a}$')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${a}$$')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '$']);
+      assert.deepStrictEqual(inspect(parser, input('${a}$0')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '0']);
+      assert.deepStrictEqual(inspect(parser, input('${a}$b')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('${ab}$')), [['<span class="math" translate="no" data-src="${ab}$">${ab}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${a b}$')), [['<span class="math" translate="no" data-src="${a b}$">${a b}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${a }$')), [['<span class="math" translate="no" data-src="${a }$">${a }$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${ a}$')), [['<span class="math" translate="no" data-src="${ a}$">${ a}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${ a }$')), [['<span class="math" translate="no" data-src="${ a }$">${ a }$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${``"}$')), [['<span class="math" translate="no" data-src="${``&quot;}$">${``"}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${\\a}$')), [['<span class="math" translate="no" data-src="${\\a}$">${\\a}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${\\$}$')), [['<span class="math" translate="no" data-src="${\\$}$">${\\$}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${\\\\}$')), [['<span class="math" translate="no" data-src="${\\\\}$">${\\\\}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${あ}$')), [['<span class="math" translate="no" data-src="${あ}$">${あ}$</span>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser, input('${*a*}$', new Context())), [['<span class="math" translate="no" data-src="${*a*}$">${*a*}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('${<wbr>}$', new Context())), [['<span class="math" translate="no" data-src="${&lt;wbr&gt;}$">${&lt;wbr&gt;}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${*a*}$')), [['<span class="math" translate="no" data-src="${*a*}$">${*a*}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('${<wbr>}$')), [['<span class="math" translate="no" data-src="${&lt;wbr&gt;}$">${&lt;wbr&gt;}$</span>'], '']);
     });
 
   });