securemark 0.295.0 → 0.295.2

package/src/parser/inline/link.ts

@@ -1,7 +1,6 @@
-import { MarkdownParser } from '../../../markdown';
 import { LinkParser } from '../inline';
-import { State, Backtrack, Command } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { Context, State, Backtrack, Command } from '../context';
+import { List, Node } from '../../combinator/data/parser';
 import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
@@ -27,10 +26,10 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
       [3 | Backtrack.common | Backtrack.link, 2 | Backtrack.ruby],
       ([, ns = new List()], context) => {
         if (context.linebreak !== 0) {
-          const head = context.position - context.range!;
+          const head = context.position - context.range;
           return void setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head);
         }
-        return ns.push(new Data(Command.Separator)) && ns;
+        return ns.push(new Node(Command.Separator)) && ns;
       })),
     // `{ `と`{`で個別にバックトラックが発生し+1nされる。
     // 自己再帰的にパースしてもオプションの不要なパースによる計算量の増加により相殺される。
@@ -41,35 +40,35 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
       false, [],
       undefined,
       ([as, bs]) =>
-        bs && as.import(bs).push(new Data(Command.Cancel)) && as)),
+        bs && as.import(bs).push(new Node(Command.Cancel)) && as)),
   ]),
   ([{ value: content }, { value: params = undefined } = {}], context) => {
     if (content.last!.value === Command.Separator) {
       content.pop();
       if (params === undefined) {
-        const head = context.position - context.range!;
+        const head = context.position - context.range;
         return void setBacktrack(context, 2 | Backtrack.link, head);
       }
     }
     else {
-      params = content as List<Data<string>>;
+      params = content as List<Node<string>>;
       content = new List();
     }
     if (params.last!.value === Command.Cancel) {
       params.pop();
       return new List([
-        new Data(html('span',
+        new Node(html('span',
           {
             class: 'invalid',
             ...invalid('link', 'syntax', 'Missing the closing symbol "}"')
           },
-          context.source.slice(context.position - context.range!, context.position)))
+          context.source.slice(context.position - context.range, context.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 Data(parse(content, params as List<Data<string>>, context))]);
+    return new List([new Node(parse(content, params as List<Node<string>>, context))]);
   })))));
 
 export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media,
@@ -82,7 +81,7 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State
     dup(surround(/{(?![{}])/y, inits([uri, some(option)]), / ?}/y)),
   ]),
   ([{ value: content }, { value: params }], context) =>
-    new List([new Data(parse(content, params as List<Data<string>>, context))])))));
+    new List([new Node(parse(content, params as List<Node<string>>, context))])))));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
   open(/ /y, str(/\S+/y)),
@@ -90,15 +89,15 @@ export const uri: LinkParser.ParameterParser.UriParser = union([
 ]);
 
 export const option: LinkParser.ParameterParser.OptionParser = union([
-  fmap(str(/ nofollow(?=[ }])/y), () => new List([new Data(' rel="nofollow"')])),
+  fmap(str(/ nofollow(?=[ }])/y), () => new List([new Node(' rel="nofollow"')])),
   str(/ [a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[ }])/yi),
   str(/ [^\s{}]+/y),
 ]);
 
 export function parse(
-  content: List<Data<string | HTMLElement>>,
-  params: List<Data<string>>,
-  context: MarkdownParser.Context,
+  content: List<Node<string | HTMLElement>>,
+  params: List<Node<string>>,
+  context: Context,
 ): HTMLAnchorElement {
   assert(params.length > 0);
   const INSECURE_URI = params.shift()!.value;
@@ -125,7 +124,7 @@ export function parse(
 
 function elem(
   INSECURE_URI: string,
-  content: List<Data<string | HTMLElement>>,
+  content: List<Node<string | HTMLElement>>,
   uri: ReadonlyURL | undefined,
   origin: string,
 ): HTMLAnchorElement {

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

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

package/src/parser/inline/mark.ts

@@ -1,6 +1,6 @@
 import { MarkParser } from '../inline';
 import { State, Recursion, Command } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, state, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
@@ -18,12 +18,12 @@ export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mar
     ])))),
     '==',
     false, [],
-    ([, bs], { buffer }) => buffer!.import(bs),
-    ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
+    ([, bs], { buffer }) => buffer.import(bs),
+    ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
     (nodes, { id }) => {
       const el = html('mark', defrag(unwrap(nodes)));
       define(el, { id: identity('mark', id, signature(el)) });
       return el.id
-        ? new List([new Data(el), new Data(html('a', { href: `#${el.id}` }))])
-        : new List([new Data(el)]);
+        ? new List([new Node(el), new Node(html('a', { href: `#${el.id}` }))])
+        : new List([new Node(el)]);
     })))));

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

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

package/src/parser/inline/math.ts

@@ -1,6 +1,6 @@
 import { MathParser } from '../inline';
 import { Backtrack, Recursion } from '../context';
-import { List, Data } from '../../combinator/data/parser';
+import { List, Node } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, rewrite, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { invalid } from '../util';
@@ -27,7 +27,7 @@ export const math: MathParser = lazy(() => rewrite(
       [3 | Backtrack.escapable]),
   ]),
   ({ context: { source, caches: { math: cache } = {} } }) => new List([
-    new Data(cache?.get(source)?.cloneNode(true) ||
+    new Node(cache?.get(source)?.cloneNode(true) ||
     html('span',
       !forbiddenCommand.test(source)
         ? { class: 'math', translate: 'no', 'data-src': source }