securemark 0.299.4 → 0.300.0

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

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

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

@@ -1,7 +1,7 @@
 import { ExtensionParser } from '../../inline';
 import { Recursion, Backtrack } from '../../context';
-import { List, Node } from '../../../combinator/data/parser';
-import { union, some, recursion, precedence, surround, lazy } from '../../../combinator';
+import { List, Node } from '../../../combinator/parser';
+import { union, some, recursion, precedence, backtrack, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { beforeNonblank } from '../../visibility';
@@ -12,20 +12,19 @@ import { html } from 'typed-dom/dom';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => backtrack(surround(
   // ^はabbrで使用済みだが^:などのようにして分離使用可能
   str(/\[[:^|]/y, beforeNonblank),
-  precedence(1, recursion(Recursion.bracket,
+  precedence(1, recursion(Recursion.inline,
   some(union([inline]), ']', [[']', 1]]))),
   str(']'),
   false,
   [3 | Backtrack.common],
-  (_, context) => new List([
-    new Node(html('span',
+  (_, input, output) =>
+    output.append(new Node(html('span',
       {
         class: 'invalid',
         ...invalid('extension', 'syntax', `Invalid start symbol or linebreak`),
       },
-      context.source.slice(context.position - context.range, context.position)))
-  ]),
-  ([as, bs]) => bs && as.import(bs as List<Node<string>>)));
+      input.source.slice(input.position - input.range, input.position)))),
+  ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>)))));

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

@@ -1,7 +1,7 @@
 import { html, TAGS } from './html';
+import { Output } from '../../combinator/parser';
 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/html', () => {
@@ -9,131 +9,131 @@ describe('Unit: parser/inline/html', () => {
     const parser = some(html);
 
     it('hash', () => {
-      assert(TAGS.every(tag => parser(input(`<${tag}>`, new Context()))));
+      assert(TAGS.every(tag => parser(input(`<${tag}>`), new Output())));
     });
 
     it('xss', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<script>')), [['<span class="invalid">&lt;script&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<script>alert()<script>')), [['<span class="invalid">&lt;script&gt;alert()&lt;script&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<script>alert()</script>')), [['<span class="invalid">&lt;script&gt;alert()&lt;/script&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi onclick="alert()">')), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi onclick="alert()"></bdi>')), [['<span class="invalid">&lt;bdi onclick="alert()"&gt;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi onclick="alert()">a</bdi>')), [['<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>')), [['<bdi><span class="invalid">&lt;bdi onclick="alert()"&gt;a&lt;/bdi&gt;</span></bdi>'], '']);
     });
 
     it('invalid', () => {
-      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);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<0>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<aT>')), [['<span class="invalid">&lt;aT&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<a,b>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<a, b>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<T>')), [['<span class="invalid">&lt;T&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr/>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<wbr />')), [['<span class="invalid">&lt;wbr /&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>')), [['<span class="invalid">&lt;bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>z')), [['<span class="invalid">&lt;bdi&gt;z</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi></bdi>')), [['<span class="invalid">&lt;bdi&gt;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> </bdi>')), [['<span class="invalid">&lt;bdi&gt; &lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> \n</bdi>')), [['<span class="invalid">&lt;bdi&gt; \n&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> \na</bdi>')), [['<span class="invalid">&lt;bdi&gt; \na&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\\ </bdi>')), [['<span class="invalid">&lt;bdi&gt;\\ &lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>&Tab;</bdi>')), [['<span class="invalid">&lt;bdi&gt;&amp;Tab;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><wbr></bdi>')), [['<span class="invalid">&lt;bdi&gt;&lt;wbr&gt;&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\n</bdi>')), [['<span class="invalid">&lt;bdi&gt;\n&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;\na&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\\\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;\\\na&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a')), [['<span class="invalid">&lt;bdi&gt;a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a</BDI>')), [['<span class="invalid">&lt;bdi&gt;a&lt;/BDI&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<BDI>a</BDI>')), [['<span class="invalid">&lt;BDI&gt;</span>'], 'a</BDI>']);
+      assert.deepStrictEqual(inspect(parser, input('<BDI>a</bdi>')), [['<span class="invalid">&lt;BDI&gt;</span>'], 'a</bdi>']);
+      assert.deepStrictEqual(inspect(parser, input('</bdi>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<bdi/>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<bdi />')), [['<span class="invalid">&lt;bdi /&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<b><b><b>a</b></b></b>')), [['<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>')), [['<bdi><bdi><bdi>a</bdi></bdi></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<x a="*b*"')), [['<span class="invalid">&lt;x a="*b*"</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<x a="*b*">')), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<x a="*b*">c')), [['<span class="invalid">&lt;x a="*b*"&gt;</span>'], 'c']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a="*b*"')), [['<span class="invalid">&lt;bdi a="*b*"</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a="*b*">')), [['<span class="invalid">&lt;bdi a="*b*"&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a="*b*">c')), [['<span class="invalid">&lt;bdi a="*b*"&gt;c</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *c*')), [['<span class="invalid">&lt;bdi a b="*" *c*</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *c*>')), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *c*>d</bdi>')), [['<span class="invalid">&lt;bdi a b="*" *c*&gt;d&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *>*c*')), [['<span class="invalid">&lt;bdi a b="*" *&gt;*c*</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi a b="*" *>*c*</bdi>')), [['<span class="invalid">&lt;bdi a b="*" *&gt;*c*&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' <bdi>a</bdi>')), undefined);
     });
 
     it('basic', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr>')), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr >')), [['<wbr>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr  >')), [['<span class="invalid">&lt;wbr </span>'], ' >']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr>a')), [['<wbr>'], 'a']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi >a</bdi>')), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi  >a</bdi>')), [['<span class="invalid">&lt;bdi  &gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> a</bdi>')), [['<bdi> a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi> a </bdi>')), [['<bdi> a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>  a  </bdi>')), [['<bdi> a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>\\ a</bdi>')), [['<bdi> a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><wbr>a</bdi>')), [['<bdi><wbr>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a</bdi>')), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a</bdi>a')), [['<bdi>a</bdi>'], 'a']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a </bdi>')), [['<bdi>a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a \n </bdi>')), [['<bdi>a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\n</bdi>')), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\n </bdi>')), [['<bdi>a </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\n<wbr></bdi>')), [['<bdi>a<wbr></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a\nb</bdi>')), [['<bdi>a<br>b</bdi>'], '']);
     });
 
     it('nest', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>[% </bdi>')), [['<span class="invalid">&lt;bdi&gt;[% &lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><bdi>a</bdi></bdi>')), [['<bdi><bdi>a</bdi></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>a<bdi>b</bdi>c</bdi>')), [['<bdi>a<bdi>b</bdi>c</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi>`a`</bdi>')), [['<bdi><code data-src="`a`">a</code></bdi>'], '']);
     });
 
     it('escape', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<a>')), [['<span class="invalid">&lt;a&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><a>a</a></bdi>')), [['<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>')), [['<bdi>a<span class="invalid">&lt;a&gt;b&lt;/a&gt;</span>c</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<img>')), [['<span class="invalid">&lt;img&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi><img></bdi>')), [['<bdi><span class="invalid">&lt;img&gt;</span></bdi>'], '']);
     });
 
     it('attribute', () => {
-      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>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi\n>a</bdi>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<bdi \n>a</bdi>')), [['<span class="invalid">&lt;bdi \n&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi __proto__>a</bdi>')), [['<span class="invalid">&lt;bdi __proto__&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi constructor>a</bdi>')), [['<span class="invalid">&lt;bdi constructor&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi toString>a</bdi>')), [['<span class="invalid">&lt;bdi toString&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi X>a</bdi>')), [['<span class="invalid">&lt;bdi X&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdi x>a</bdi>')), [['<span class="invalid">&lt;bdi x&gt;a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo>a</bdo>')), [['<span class="invalid">&lt;bdo&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo >a</bdo>')), [['<span class="invalid">&lt;bdo &gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo __proto__>a</bdo>')), [['<span class="invalid">&lt;bdo __proto__&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo constructor>a</bdo>')), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo toString>a</bdo>')), [['<span class="invalid">&lt;bdo toString&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo X>a</bdo>')), [['<span class="invalid">&lt;bdo X&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo x>a</bdo>')), [['<span class="invalid">&lt;bdo x&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir>a</bdo>')), [['<span class="invalid">&lt;bdo dir&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir=>a</bdo>')), [['<span class="invalid">&lt;bdo dir=&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir=rtl>a</bdo>')), [['<span class="invalid">&lt;bdo dir=rtl&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir=">a</bdo>')), [['<span class="invalid">&lt;bdo dir="&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="">a</bdo>')), [['<span class="invalid">&lt;bdo dir=""&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl" dir="rtl">a</bdo>')), [['<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>')), [['<span class="invalid">&lt;bdo diR="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl" >a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo dir="rtl"  >a</bdo>')), [['<span class="invalid">&lt;bdo dir="rtl"  &gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<bdo  dir="rtl">a</bdo>')), [['<span class="invalid">&lt;bdo  dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr\n>')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('<wbr \n>')), [['<span class="invalid">&lt;wbr </span>'], '\n>']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr constructor>')), [['<span class="invalid">&lt;wbr constructor&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr X>')), [['<span class="invalid">&lt;wbr X&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('<wbr x>')), [['<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, Node, Context } from '../../combinator/data/parser';
+import { Input, Recursion } from '../context';
+import { List, Node } from '../../combinator/parser';
 import { Flag } from '../node';
 import { union, some, recursion, precedence, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
@@ -27,22 +27,22 @@ export const html: HTMLParser = lazy(() => union([
     precedence(9, some(union([attribute]))),
     open(str(/ ?/y), str('>'), true),
     true, [],
-    ([as, bs = new List(), cs], context) =>
-      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.blank : Flag.none)]),
-    ([as, bs = new List()], context) =>
-      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+    ([as, bs = new List(), cs], input, output) =>
+      output.append(new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), input), as.head!.value === '<wbr' ? Flag.blank : Flag.none)),
+    ([as, bs = new List()], input, output) =>
+      output.append(new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), input)))),
   match(
     new RegExp(String.raw`<(${TAGS.join('|')})(?=[ >])`, 'y'),
     memoize(
     ([, tag]) =>
-      surround<HTMLParser.TagParser, string>(
-        surround(
+      surround<HTMLParser.TagParser>(
+        surround<HTMLParser.VoidTagParser>(
           str(`<${tag}`),
           precedence(9, some(attribute)),
           open(str(/ ?/y), str('>'), true),
           true, [],
-          ([as, bs = new List(), cs]) => as.import(bs).import(cs),
-          ([as, bs = new List()]) => as.import(bs)),
+          ([as, bs = new List(), cs], _, output) => output.import(as.import(bs).import(cs)),
+          ([as, bs = new List()], _, output) => output.import(as.import(bs))),
         // 不可視のHTML構造が可視構造を変化させるべきでない。
         // 可視のHTMLは優先度変更を検討する。
         // このため`<>`記号は将来的に共通構造を変化させる可能性があり
@@ -54,10 +54,10 @@ export const html: HTMLParser = lazy(() => union([
         ])))),
         str(`</${tag}>`),
         true, [],
-        ([as, bs = new List(), cs], context) =>
-          new List([new Node(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
-        ([as, bs = new List()], context) =>
-          new List([new Node(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
+        ([as, bs = new List(), cs], input, output) =>
+          output.append(new Node(elem(tag, true, [...unwrap(as)], bs, cs, input))),
+        ([as, bs = new List()], input, output) =>
+          output.append(new Node(elem(tag, true, [...unwrap(as)], bs, new List(), input)))),
     ([, tag]) => tag2index(tag),
     Array(TAGS.length))),
   surround(
@@ -66,10 +66,10 @@ export const html: HTMLParser = lazy(() => union([
     precedence(9, some(union([attribute]))),
     open(str(/ ?/y), str('>'), true),
     true, [],
-    ([as, bs = new List(), cs], 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 Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+    ([as, bs = new List(), cs], input, output) =>
+      output.append(new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), input))),
+    ([as, bs = new List()], input, output) =>
+      output.append(new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), input)))),
 ]));
 
 export const attribute: HTMLParser.AttributeParser = union([
@@ -77,25 +77,25 @@ export const attribute: HTMLParser.AttributeParser = union([
   str(/ [^\s<>]+/y),
 ]);
 
-function elem(tag: string, content: boolean, as: readonly string[], bs: List<Node<HTMLElement | string>>, cs: List<Node<string>>, context: Context): HTMLElement {
+function elem(tag: string, content: boolean, as: readonly string[], bs: List<Node<HTMLElement | string>>, cs: List<Node<string>>, input: Input): HTMLElement {
   assert(as.length > 0);
   assert(as[0][0] === '<');
-  if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, context);
+  if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, input);
   if (content) {
-    if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, context);
-    if (bs.length === 0) return ielem('content', `Missing the content`, context);
-    if (!isNonblankFirstLine(bs)) return ielem('content', `Missing the visible content in the same line`, context);
+    if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, input);
+    if (bs.length === 0) return ielem('content', `Missing the content`, input);
+    if (!isNonblankFirstLine(bs)) return ielem('content', `Missing the visible content in the same line`, input);
   }
   const [attrs] = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
-  if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', context)
-  if (as.at(-1) !== '>') return ielem('tag', `Missing the closing symbol ">"`, context);
+  if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', input)
+  if (as.at(-1) !== '>') return ielem('tag', `Missing the closing symbol ">"`, input);
   return h(tag as 'span', attrs, defrag(unwrap(bs)));
 }
 
-function ielem(type: string, message: string, context: Context): HTMLElement {
+function ielem(type: string, message: string, input: Input): HTMLElement {
   return h('span',
     { class: 'invalid', ...invalid('html', type, message) },
-    context.source.slice(context.position - context.range, context.position));
+    input.source.slice(input.position - input.range, input.position));
 }
 
 const requiredAttributes = memoize(