securemark 0.291.1 → 0.293.0

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

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

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

@@ -6,22 +6,25 @@ import { str } from '../../source';
 import { tightStart } from '../../visibility';
 import { invalid } from '../../util';
 import { unshift } from 'spica/array';
-import { html, defrag } from 'typed-dom/dom';
+import { html } from 'typed-dom/dom';
 
 // Don't use the symbols already used: !#$%@&*+~=|
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
 export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surround(
-  str(/^\[[:^|]/),
+  // ^はabbrで使用済みだが^:などのようにして分離使用可能
+  str(/\[[:^|]/y),
   precedence(1, recursion(Recursion.inline,
   tightStart(some(union([inline]), ']', [[']', 1]])))),
   str(']'), false,
-  ([, bs], rest) => [[
-    html('span', {
-      class: 'invalid',
-      ...invalid('extension', 'syntax', `Invalid start symbol or linebreak`),
-    }, defrag(bs)),
-  ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest],
+  (_, context) => [[
+    html('span',
+      {
+        class: 'invalid',
+        ...invalid('extension', 'syntax', `Invalid start symbol or linebreak`),
+      },
+      context.source.slice(context.position - context.range!, context.position))
+  ]],
+  ([as, bs]) => bs && [unshift(as, bs)],
   [3 | Backtrack.bracket]));

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

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

package/src/parser/inline/html.ts

@@ -1,6 +1,7 @@
 import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
-import { union, subsequence, some, recursion, precedence, validate, focus, surround, open, match, lazy } from '../../combinator';
+import { Ctx } from '../../combinator/data/parser';
+import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { isLooseNodeStart, blankWith } from '../visibility';
@@ -19,77 +20,77 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
+export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
   union([
     surround(
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/^<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/i),
+      str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/yi),
       some(union([attribute])),
-      open(str(/^[^\S\n]*/), str('>'), true),
+      open(str(/[^\S\n]*/y), str('>'), true),
       true,
-      ([as, bs = [], cs], rest) =>
-        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [])], rest],
-      ([as, bs = []], rest) =>
-        [[elem(as[0].slice(1), false, unshift(as, bs), [], [])], rest]),
+      ([as, bs = [], cs], context) =>
+        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
+      ([as, bs = []], context) =>
+        [[elem(as[0].slice(1), false, unshift(as, bs), [], [], context)]]),
     match(
-      new RegExp(String.raw`^<(${TAGS.join('|')})(?=[^\S\n]|>)`),
+      new RegExp(String.raw`<(${TAGS.join('|')})(?=[^\S\n]|>)`, 'y'),
       memoize(
       ([, tag]) =>
         surround<HTMLParser.TagParser, string>(
           surround(
-            str(`<${tag}`), some(attribute), open(str(/^[^\S\n]*/), str('>'), true),
+            str(`<${tag}`), some(attribute), open(str(/[^\S\n]*/y), str('>'), true),
             true,
-            ([as, bs = [], cs], rest) => [push(unshift(as, bs), cs), rest],
-            ([as, bs = []], rest) => [unshift(as, bs), rest]),
+            ([as, bs = [], cs]) => [push(unshift(as, bs), cs)],
+            ([as, bs = []]) => [unshift(as, bs)]),
           precedence(3, recursion(Recursion.inline,
-          subsequence([
-            focus(/^[^\S\n]*\n/, some(inline)),
-            some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]), true)),
-          ]))),
+          some(union([
+            some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]),
+            open('\n', some(inline, `</${tag}>`, [[`</${tag}>`, 3]]), true),
+          ])))),
           str(`</${tag}>`),
           true,
-          ([as, bs = [], cs], rest) =>
-            [[elem(tag, true, as, bs, cs)], rest],
-          ([as, bs = []], rest) =>
-            [[elem(tag, true, as, bs, [])], rest]),
+          ([as, bs = [], cs], context) =>
+            [[elem(tag, true, as, bs, cs, context)]],
+          ([as, bs = []], context) =>
+            [[elem(tag, true, as, bs, [], context)]]),
       ([, tag]) => tag,
       new Map())),
     surround(
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/^<[a-z]{1,16}(?=[^\S\n]|>)/i),
+      str(/<[a-z]+(?=[^\S\n]|>)/yi),
       some(union([attribute])),
-      open(str(/^[^\S\n]*/), str('>'), true),
+      open(str(/[^\S\n]*/y), str('>'), true),
       true,
-      ([as, bs = [], cs], rest) =>
-        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [])], rest],
-      ([as, bs = []], rest) =>
-        [[elem(as[0].slice(1), false, unshift(as, bs), [], [])], rest]),
+      ([as, bs = [], cs], context) =>
+        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
+      ([as, bs = []], context) =>
+        [[elem(as[0].slice(1), false, unshift(as, bs), [], [], context)]]),
   ])));
 
 export const attribute: HTMLParser.AttributeParser = union([
-  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/i),
-  str(/^[^\S\n]+[^\s<>]+/),
+  str(/[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/yi),
+  str(/[^\S\n]+[^\s<>]+/y),
 ]);
 
-function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | string)[], cs: string[]): HTMLElement {
+function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | string)[], cs: string[], context: Ctx): HTMLElement {
   assert(as.length > 0);
   assert(as[0][0] === '<');
-  if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, as, bs, cs);
+  if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, context);
   if (content) {
-    if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, as, bs, cs);
-    if (bs.length === 0) return ielem('content', `Missing the content`, as, bs, cs);
-    if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, as, bs, cs);
+    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 (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, context);
   }
   const attrs = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -2 : as.length));
-  if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', as, bs, cs)
-  if (as.at(-1) !== '>') return ielem('tag', `Missing the closing bracket ">"`, as, bs, cs);
+  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);
   return h(tag as 'span', attrs, defrag(bs));
 }
 
-function ielem(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
+function ielem(type: string, message: string, context: Ctx): HTMLElement {
   return h('span',
     { class: 'invalid', ...invalid('html', type, message) },
-    defrag(push(unshift(as, bs), cs)));
+    context.source.slice(context.position - context.range!, context.position));
 }
 
 const requiredAttributes = memoize(