securemark 0.295.0 → 0.295.2

package/src/parser/inline/extension/placeholder.test.ts

@@ -1,58 +1,58 @@
 import { placeholder } from './placeholder';
 import { some } from '../../../combinator';
 import { input } from '../../../combinator/data/parser';
+import { Context } from '../../context';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/inline/extension/placeholder', () => {
   describe('placeholder', () => {
-    const parser = (source: string) => some(placeholder)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(placeholder);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('[]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[a]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[ab]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^\\]'), ctx), [['[^', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[^ ]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^ a]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^\\ ]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^\\ a]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^\n]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^\na]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^\\\na]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^ !http://host]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[^a'), ctx), [['[^', 'a'], '']);
-      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(' [^a]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[a]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ab]', 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())), [['[^', ']'], '']);
+      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]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[^\n]', 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('[^ !http://host]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[^a', new Context())), [['[^', 'a'], '']);
+      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(' [^a]', new Context())), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('[^a]'), ctx), [['<span class="invalid">[^a]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a b]'), ctx), [['<span class="invalid">[^a b]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a ]'), ctx), [['<span class="invalid">[^a ]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a  ]'), ctx), [['<span class="invalid">[^a  ]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\ ]'), ctx), [['<span class="invalid">[^a\\ ]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\ \\ ]'), ctx), [['<span class="invalid">[^a\\ \\ ]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\n]'), ctx), [['<span class="invalid">[^a\n]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\n]'), ctx), [['<span class="invalid">[^a\\\n]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\nb]'), ctx), [['<span class="invalid">[^a\nb]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\nb]'), ctx), [['<span class="invalid">[^a\\\nb]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a<wbr>]'), ctx), [['<span class="invalid">[^a&lt;wbr&gt;]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a<wbr><wbr>]'), ctx), [['<span class="invalid">[^a&lt;wbr&gt;&lt;wbr&gt;]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^==]'), ctx), [['<span class="invalid">[^==]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a[% b %]]'), ctx), [['<span class="invalid">[^a[% b %]]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a[% b %][% c %]]'), ctx), [['<span class="invalid">[^a[% b %][% c %]]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^\\]]'), ctx), [['<span class="invalid">[^\\]]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^(])]'), ctx), [['<span class="invalid">[^(])]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^!http://host]'), ctx), [['<span class="invalid">[^!http://host]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^[% a %]]'), ctx), [['<span class="invalid">[^[% a %]]</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^[% a %]b]'), ctx), [['<span class="invalid">[^[% a %]b]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a]', new Context())), [['<span class="invalid">[^a]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a b]', new Context())), [['<span class="invalid">[^a b]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a ]', new Context())), [['<span class="invalid">[^a ]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a  ]', new Context())), [['<span class="invalid">[^a  ]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a\\ ]', new Context())), [['<span class="invalid">[^a\\ ]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a\\ \\ ]', new Context())), [['<span class="invalid">[^a\\ \\ ]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a\n]', new Context())), [['<span class="invalid">[^a\n]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a\\\n]', new Context())), [['<span class="invalid">[^a\\\n]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a\nb]', new Context())), [['<span class="invalid">[^a\nb]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a\\\nb]', new Context())), [['<span class="invalid">[^a\\\nb]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a<wbr>]', new Context())), [['<span class="invalid">[^a&lt;wbr&gt;]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a<wbr><wbr>]', new Context())), [['<span class="invalid">[^a&lt;wbr&gt;&lt;wbr&gt;]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^==]', new Context())), [['<span class="invalid">[^==]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a[% b %]]', new Context())), [['<span class="invalid">[^a[% b %]]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^a[% b %][% c %]]', new Context())), [['<span class="invalid">[^a[% b %][% c %]]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^\\]]', new Context())), [['<span class="invalid">[^\\]]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^(])]', new Context())), [['<span class="invalid">[^(])]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^!http://host]', new Context())), [['<span class="invalid">[^!http://host]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^[% a %]]', new Context())), [['<span class="invalid">[^[% a %]]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[^[% a %]b]', new Context())), [['<span class="invalid">[^[% a %]b]</span>'], '']);
     });
 
   });

package/src/parser/inline/extension/placeholder.ts

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { Recursion, Backtrack } from '../../context';
-import { List, Data } from '../../../combinator/data/parser';
+import { List, Node } from '../../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
@@ -21,11 +21,11 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surroun
   false,
   [3 | Backtrack.common],
   (_, context) => new List([
-    new Data(html('span',
+    new Node(html('span',
       {
         class: 'invalid',
         ...invalid('extension', 'syntax', `Invalid start symbol or linebreak`),
       },
-      context.source.slice(context.position - context.range!, context.position)))
+      context.source.slice(context.position - context.range, context.position)))
   ]),
-  ([as, bs]) => bs && as.import(bs as List<Data<string>>)));
+  ([as, bs]) => bs && as.import(bs as List<Node<string>>)));

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

@@ -1,135 +1,135 @@
 import { html } from './html';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/html', () => {
   describe('html', () => {
-    const parser = (source: string) => some(html)(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = some(html);
 
     it('xss', () => {
-      assert.deepStrictEqual(inspect(parser('<script>'), ctx), [['<span class="invalid">&lt;script&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<script>alert()<script>'), ctx), [['<span class="invalid">&lt;script&gt;alert()&lt;script&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<script>alert()</script>'), ctx), [['<span class="invalid">&lt;script&gt;alert()&lt;/script&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi onclick="alert()">'), ctx), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi onclick="alert()"></bdi>'), ctx), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi onclick="alert()">a</bdi>'), ctx), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi><bdi onclick="alert()">a</bdi></bdi>'), ctx), [['<bdi><span class="invalid">&lt;bdi onclick="alert()"&gt;a&lt;/bdi&gt;</span></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<script>', new Context())), [['<span class="invalid">&lt;script&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<script>alert()<script>', new Context())), [['<span class="invalid">&lt;script&gt;alert()&lt;script&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<script>alert()</script>', new Context())), [['<span class="invalid">&lt;script&gt;alert()&lt;/script&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi onclick="alert()">', new Context())), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi onclick="alert()"></bdi>', new Context())), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi onclick="alert()">a</bdi>', new Context())), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><bdi onclick="alert()">a</bdi></bdi>', new Context())), [['<bdi><span class="invalid">&lt;bdi onclick="alert()"&gt;a&lt;/bdi&gt;</span></bdi>'], '']);
     });
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<0>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<aT>'), ctx), [['<span class="invalid">&lt;aT&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<a,b>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<a, b>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<T>'), ctx), [['<span class="invalid">&lt;T&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<wbr/>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<wbr />'), ctx), [['<span class="invalid">&lt;wbr /&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>z'), ctx), [['<span class="invalid">&lt;bdi&gt;z</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi></bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi> </bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt; &lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi> \n</bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt; \n&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi> \na</bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt; \na&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>\\ </bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;\\ &lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>&Tab;</bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;&amp;Tab;&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi><wbr></bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;&lt;wbr&gt;&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>\n</bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;\n&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>\na</bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;\na&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>\\\na</bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;\\\na&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a'), ctx), [['<span class="invalid">&lt;bdi&gt;a</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a</BDI>'), ctx), [['<span class="invalid">&lt;bdi&gt;a&lt;/BDI&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<BDI>a</BDI>'), ctx), [['<span class="invalid">&lt;BDI&gt;</span>'], 'a</BDI>']);
-      assert.deepStrictEqual(inspect(parser('<BDI>a</bdi>'), ctx), [['<span class="invalid">&lt;BDI&gt;</span>'], 'a</bdi>']);
-      assert.deepStrictEqual(inspect(parser('</bdi>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi/>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi />'), ctx), [['<span class="invalid">&lt;bdi /&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<b><b><b>a</b></b></b>'), ctx), [['<span class="invalid">&lt;b&gt;&lt;b&gt;&lt;b&gt;a&lt;/b&gt;&lt;/b&gt;&lt;/b&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi><bdi><bdi>a</bdi></bdi></bdi>'), ctx), [['<bdi><bdi><bdi>a</bdi></bdi></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<x a="*b*"'), ctx), [['<span class="invalid">&lt;x a="*b*"</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<x a="*b*">'), ctx), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<x a="*b*">c'), ctx), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], 'c']);
-      assert.deepStrictEqual(inspect(parser('<bdi a="*b*"'), ctx), [['<span class="invalid">&lt;bdi a="*b*"</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a="*b*">'), ctx), [['<span class="invalid">&lt;bdi a="*b*"&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a="*b*">c'), ctx), [['<span class="invalid">&lt;bdi a="*b*"&gt;c</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*'), ctx), [['<span class="invalid">&lt;bdi a b="*" *c*</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*>'), ctx), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *c*>d</bdi>'), ctx), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;d&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *>*c*'), ctx), [['<span class="invalid">&lt;bdi a b="*" *&gt;*c*</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi a b="*" *>*c*</bdi>'), ctx), [['<span class="invalid">&lt;bdi a b="*" *&gt;*c*&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser(' <bdi>a</bdi>'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<0>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<aT>', new Context())), [['<span class="invalid">&lt;aT&gt;</span>'], '']);
+      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('<T>', new Context())), [['<span class="invalid">&lt;T&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr/>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<wbr />', new Context())), [['<span class="invalid">&lt;wbr /&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>z', new Context())), [['<span class="invalid">&lt;bdi&gt;z</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi></bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> </bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt; &lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> \n</bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt; \n&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> \na</bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt; \na&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\\ </bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;\\ &lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>&Tab;</bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;&amp;Tab;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><wbr></bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;&lt;wbr&gt;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\n</bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;\n&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\na</bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;\na&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\\\na</bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;\\\na&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a', new Context())), [['<span class="invalid">&lt;bdi&gt;a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a</BDI>', new Context())), [['<span class="invalid">&lt;bdi&gt;a&lt;/BDI&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<BDI>a</BDI>', new Context())), [['<span class="invalid">&lt;BDI&gt;</span>'], 'a</BDI>']);
+      assert.deepStrictEqual(inspect(parser, input('<BDI>a</bdi>', new Context())), [['<span class="invalid">&lt;BDI&gt;</span>'], 'a</bdi>']);
+      assert.deepStrictEqual(inspect(parser, input('</bdi>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<bdi/>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<bdi />', new Context())), [['<span class="invalid">&lt;bdi /&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<b><b><b>a</b></b></b>', new Context())), [['<span class="invalid">&lt;b&gt;&lt;b&gt;&lt;b&gt;a&lt;/b&gt;&lt;/b&gt;&lt;/b&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><bdi><bdi>a</bdi></bdi></bdi>', new Context())), [['<bdi><bdi><bdi>a</bdi></bdi></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<x a="*b*"', new Context())), [['<span class="invalid">&lt;x a="*b*"</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<x a="*b*">', new Context())), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<x a="*b*">c', new Context())), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], 'c']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a="*b*"', new Context())), [['<span class="invalid">&lt;bdi a="*b*"</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a="*b*">', new Context())), [['<span class="invalid">&lt;bdi a="*b*"&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a="*b*">c', new Context())), [['<span class="invalid">&lt;bdi a="*b*"&gt;c</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *c*', new Context())), [['<span class="invalid">&lt;bdi a b="*" *c*</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *c*>', new Context())), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *c*>d</bdi>', new Context())), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;d&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *>*c*', new Context())), [['<span class="invalid">&lt;bdi a b="*" *&gt;*c*</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *>*c*</bdi>', new Context())), [['<span class="invalid">&lt;bdi a b="*" *&gt;*c*&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' <bdi>a</bdi>', new Context())), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('<wbr>'), ctx), [['<wbr>'], '']);
-      assert.deepStrictEqual(inspect(parser('<wbr >'), ctx), [['<wbr>'], '']);
-      assert.deepStrictEqual(inspect(parser('<wbr  >'), ctx), [['<span class="invalid">&lt;wbr </span>'], ' >']);
-      assert.deepStrictEqual(inspect(parser('<wbr>a'), ctx), [['<wbr>'], 'a']);
-      assert.deepStrictEqual(inspect(parser('<bdi >a</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>'), ctx), [['<span class="invalid">&lt;bdi  &gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi> a</bdi>'), ctx), [['<bdi> a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi> a </bdi>'), ctx), [['<bdi> a </bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>  a  </bdi>'), ctx), [['<bdi> a </bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>\\ a</bdi>'), ctx), [['<bdi> a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi><wbr>a</bdi>'), ctx), [['<bdi><wbr>a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a</bdi>a'), ctx), [['<bdi>a</bdi>'], 'a']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a </bdi>'), ctx), [['<bdi>a </bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a \n </bdi>'), ctx), [['<bdi>a </bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a\n</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a\n </bdi>'), ctx), [['<bdi>a </bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a\n<wbr></bdi>'), ctx), [['<bdi>a<wbr></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a\nb</bdi>'), ctx), [['<bdi>a<br>b</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr>', new Context())), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr >', new Context())), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr  >', new Context())), [['<span class="invalid">&lt;wbr </span>'], ' >']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr>a', new Context())), [['<wbr>'], 'a']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi >a</bdi>', new Context())), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi  >a</bdi>', new Context())), [['<span class="invalid">&lt;bdi  &gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> a</bdi>', new Context())), [['<bdi> a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> a </bdi>', new Context())), [['<bdi> a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>  a  </bdi>', new Context())), [['<bdi> a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\\ a</bdi>', new Context())), [['<bdi> a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><wbr>a</bdi>', new Context())), [['<bdi><wbr>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a</bdi>', new Context())), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a</bdi>a', new Context())), [['<bdi>a</bdi>'], 'a']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a </bdi>', new Context())), [['<bdi>a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a \n </bdi>', new Context())), [['<bdi>a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\n</bdi>', new Context())), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\n </bdi>', new Context())), [['<bdi>a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\n<wbr></bdi>', new Context())), [['<bdi>a<wbr></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\nb</bdi>', new Context())), [['<bdi>a<br>b</bdi>'], '']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('<bdi>[% </bdi>'), ctx), [['<span class="invalid">&lt;bdi&gt;[% &lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi><bdi>a</bdi></bdi>'), ctx), [['<bdi><bdi>a</bdi></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a<bdi>b</bdi>c</bdi>'), ctx), [['<bdi>a<bdi>b</bdi>c</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>`a`</bdi>'), ctx), [['<bdi><code data-src="`a`">a</code></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>[% </bdi>', new Context())), [['<span class="invalid">&lt;bdi&gt;[% &lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><bdi>a</bdi></bdi>', new Context())), [['<bdi><bdi>a</bdi></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a<bdi>b</bdi>c</bdi>', new Context())), [['<bdi>a<bdi>b</bdi>c</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>`a`</bdi>', new Context())), [['<bdi><code data-src="`a`">a</code></bdi>'], '']);
     });
 
     it('escape', () => {
-      assert.deepStrictEqual(inspect(parser('<a>'), ctx), [['<span class="invalid">&lt;a&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi><a>a</a></bdi>'), ctx), [['<bdi><span class="invalid">&lt;a&gt;a&lt;/a&gt;</span></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a<a>b</a>c</bdi>'), ctx), [['<bdi>a<span class="invalid">&lt;a&gt;b&lt;/a&gt;</span>c</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<img>'), ctx), [['<span class="invalid">&lt;img&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi><img></bdi>'), ctx), [['<bdi><span class="invalid">&lt;img&gt;</span></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<a>', new Context())), [['<span class="invalid">&lt;a&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><a>a</a></bdi>', new Context())), [['<bdi><span class="invalid">&lt;a&gt;a&lt;/a&gt;</span></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a<a>b</a>c</bdi>', new Context())), [['<bdi>a<span class="invalid">&lt;a&gt;b&lt;/a&gt;</span>c</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<img>', new Context())), [['<span class="invalid">&lt;img&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><img></bdi>', new Context())), [['<bdi><span class="invalid">&lt;img&gt;</span></bdi>'], '']);
     });
 
     it('attribute', () => {
-      assert.deepStrictEqual(inspect(parser('<bdi\n>a</bdi>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi \n>a</bdi>'), ctx), [['<span class="invalid">&lt;bdi \n&gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi __proto__>a</bdi>'), ctx), [['<span class="invalid">&lt;bdi __proto__&gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi constructor>a</bdi>'), ctx), [['<span class="invalid">&lt;bdi constructor&gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi toString>a</bdi>'), ctx), [['<span class="invalid">&lt;bdi toString&gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi X>a</bdi>'), ctx), [['<span class="invalid">&lt;bdi X&gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi x>a</bdi>'), ctx), [['<span class="invalid">&lt;bdi x&gt;a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo >a</bdo>'), ctx), [['<span class="invalid">&lt;bdo &gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo __proto__>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo __proto__&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo constructor>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo toString>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo toString&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo X>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo X&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo x>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo x&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir=&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=rtl>a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir=rtl&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir=">a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir="&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="">a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir=""&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" dir="rtl">a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir="rtl" dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo diR="rtl">a</bdo>'), ctx), [['<span class="invalid">&lt;bdo diR="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl">a</bdo>'), ctx), [['<bdo dir="rtl">a</bdo>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" >a</bdo>'), ctx), [['<bdo dir="rtl">a</bdo>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl"  >a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir="rtl"  &gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo  dir="rtl">a</bdo>'), ctx), [['<span class="invalid">&lt;bdo  dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<wbr\n>'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('<wbr \n>'), ctx), [['<span class="invalid">&lt;wbr </span>'], '\n>']);
-      assert.deepStrictEqual(inspect(parser('<wbr constructor>'), ctx), [['<span class="invalid">&lt;wbr constructor&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<wbr X>'), ctx), [['<span class="invalid">&lt;wbr X&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<wbr x>'), ctx), [['<span class="invalid">&lt;wbr x&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi\n>a</bdi>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<bdi \n>a</bdi>', new Context())), [['<span class="invalid">&lt;bdi \n&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi __proto__>a</bdi>', new Context())), [['<span class="invalid">&lt;bdi __proto__&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi constructor>a</bdi>', new Context())), [['<span class="invalid">&lt;bdi constructor&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi toString>a</bdi>', new Context())), [['<span class="invalid">&lt;bdi toString&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi X>a</bdi>', new Context())), [['<span class="invalid">&lt;bdi X&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi x>a</bdi>', new Context())), [['<span class="invalid">&lt;bdi x&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo >a</bdo>', new Context())), [['<span class="invalid">&lt;bdo &gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo __proto__>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo __proto__&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo constructor>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo toString>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo toString&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo X>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo X&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo x>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo x&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo dir&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir=>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo dir=&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir=rtl>a</bdo>', new Context())), [['<span class="invalid">&lt;bdo dir=rtl&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir=">a</bdo>', new Context())), [['<span class="invalid">&lt;bdo dir="&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="">a</bdo>', new Context())), [['<span class="invalid">&lt;bdo dir=""&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl" dir="rtl">a</bdo>', new Context())), [['<span class="invalid">&lt;bdo dir="rtl" dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo diR="rtl">a</bdo>', new Context())), [['<span class="invalid">&lt;bdo diR="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl">a</bdo>', new Context())), [['<bdo dir="rtl">a</bdo>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl" >a</bdo>', new Context())), [['<bdo dir="rtl">a</bdo>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl"  >a</bdo>', new Context())), [['<span class="invalid">&lt;bdo dir="rtl"  &gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo  dir="rtl">a</bdo>', new Context())), [['<span class="invalid">&lt;bdo  dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr\n>', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<wbr \n>', new Context())), [['<span class="invalid">&lt;wbr </span>'], '\n>']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr constructor>', new Context())), [['<span class="invalid">&lt;wbr constructor&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr X>', new Context())), [['<span class="invalid">&lt;wbr X&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr x>', new Context())), [['<span class="invalid">&lt;wbr x&gt;</span>'], '']);
     });
 
   });

package/src/parser/inline/html.ts

@@ -1,6 +1,6 @@
 import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
-import { List, Data, Ctx } from '../../combinator/data/parser';
+import { List, Node, Context } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
@@ -28,9 +28,9 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       open(str(/ ?/y), str('>'), true),
       true, [],
       ([as, bs = new List(), cs], context) =>
-        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
       ([as, bs = new List()], context) =>
-        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
     match(
       new RegExp(String.raw`<(${TAGS.join('|')})(?=[ >])`, 'y'),
       memoize(
@@ -53,9 +53,9 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
           str(`</${tag}>`),
           true, [],
           ([as, bs = new List(), cs], context) =>
-            new List([new Data(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
+            new List([new Node(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
           ([as, bs = new List()], context) =>
-            new List([new Data(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
+            new List([new Node(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
       ([, tag]) => tag,
       new Map())),
     surround(
@@ -65,9 +65,9 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       open(str(/ ?/y), str('>'), true),
       true, [],
       ([as, bs = new List(), cs], context) =>
-        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
       ([as, bs = new List()], context) =>
-        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
   ])));
 
 export const attribute: HTMLParser.AttributeParser = union([
@@ -75,7 +75,7 @@ export const attribute: HTMLParser.AttributeParser = union([
   str(/ [^\s<>]+/y),
 ]);
 
-function elem(tag: string, content: boolean, as: readonly string[], bs: List<Data<HTMLElement | string>>, cs: List<Data<string>>, context: Ctx): HTMLElement {
+function elem(tag: string, content: boolean, as: readonly string[], bs: List<Node<HTMLElement | string>>, cs: List<Node<string>>, context: Context): HTMLElement {
   assert(as.length > 0);
   assert(as[0][0] === '<');
   if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, context);
@@ -90,10 +90,10 @@ function elem(tag: string, content: boolean, as: readonly string[], bs: List<Dat
   return h(tag as 'span', attrs, defrag(unwrap(bs)));
 }
 
-function ielem(type: string, message: string, context: Ctx): HTMLElement {
+function ielem(type: string, message: string, context: Context): HTMLElement {
   return h('span',
     { class: 'invalid', ...invalid('html', type, message) },
-    context.source.slice(context.position - context.range!, context.position));
+    context.source.slice(context.position - context.range, context.position));
 }
 
 const requiredAttributes = memoize(