securemark 0.291.1 → 0.292.0

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(
+  // ^はabbrで使用済みだが^:などのようにして分離使用可能
   str(/^\[[:^|]/),
   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,5 +1,6 @@
 import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
+import { Ctx } from '../../combinator/data/parser';
 import { union, subsequence, some, recursion, precedence, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
@@ -27,10 +28,10 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
       some(union([attribute])),
       open(str(/^[^\S\n]*/), 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]|>)`),
       memoize(
@@ -39,8 +40,8 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
           surround(
             str(`<${tag}`), some(attribute), open(str(/^[^\S\n]*/), 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)),
@@ -48,10 +49,10 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
           ]))),
           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(
@@ -60,10 +61,10 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
       some(union([attribute])),
       open(str(/^[^\S\n]*/), 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([
@@ -71,25 +72,25 @@ export const attribute: HTMLParser.AttributeParser = union([
   str(/^[^\S\n]+[^\s<>]+/),
 ]);
 
-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(

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

@@ -1,51 +1,53 @@
 import { htmlentity } from './htmlentity';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/inline/htmlentity', () => {
   describe('htmlentity', () => {
-    const parser = (source: string) => some(htmlentity)({ source, context: {} });
+    const parser = (source: string) => some(htmlentity)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('&')), undefined);
-      assert.deepStrictEqual(inspect(parser('&amp')), undefined);
-      assert.deepStrictEqual(inspect(parser('&;')), undefined);
-      assert.deepStrictEqual(inspect(parser('& ;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&\n;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&a;')), [['<span class="invalid">&amp;a;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('&#;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#g;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#x;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#-1;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&&amp;;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&*&amp*')), undefined);
-      assert.deepStrictEqual(inspect(parser('&<;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&<>;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&>;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#35;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#1234;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#992;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#98765432;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#0;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#X22;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#XD06;')), undefined);
-      assert.deepStrictEqual(inspect(parser('&#xcab;')), undefined);
-      assert.deepStrictEqual(inspect(parser(' &amp;')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('&'), ctx), [['&'], '']);
+      assert.deepStrictEqual(inspect(parser('&amp'), ctx), [['&amp'], '']);
+      assert.deepStrictEqual(inspect(parser('&;'), ctx), [['&'], ';']);
+      assert.deepStrictEqual(inspect(parser('& ;'), ctx), [['&'], ' ;']);
+      assert.deepStrictEqual(inspect(parser('&\n;'), ctx), [['&'], '\n;']);
+      assert.deepStrictEqual(inspect(parser('&a;'), ctx), [['<span class="invalid">&amp;a;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('&#;'), ctx), [['&'], '#;']);
+      assert.deepStrictEqual(inspect(parser('&#g;'), ctx), [['&'], '#g;']);
+      assert.deepStrictEqual(inspect(parser('&#x;'), ctx), [['&'], '#x;']);
+      assert.deepStrictEqual(inspect(parser('&#-1;'), ctx), [['&'], '#-1;']);
+      assert.deepStrictEqual(inspect(parser('&&amp;;'), ctx), [['&', '&'], ';']);
+      assert.deepStrictEqual(inspect(parser('&*&amp*'), ctx), [['&'], '*&amp*']);
+      assert.deepStrictEqual(inspect(parser('&<;'), ctx), [['&'], '<;']);
+      assert.deepStrictEqual(inspect(parser('&<>;'), ctx), [['&'], '<>;']);
+      assert.deepStrictEqual(inspect(parser('&>;'), ctx), [['&'], '>;']);
+      assert.deepStrictEqual(inspect(parser('&#35;'), ctx), [['&'], '#35;']);
+      assert.deepStrictEqual(inspect(parser('&#1234;'), ctx), [['&'], '#1234;']);
+      assert.deepStrictEqual(inspect(parser('&#992;'), ctx), [['&'], '#992;']);
+      assert.deepStrictEqual(inspect(parser('&#98765432;'), ctx), [['&'], '#98765432;']);
+      assert.deepStrictEqual(inspect(parser('&#0;'), ctx), [['&'], '#0;']);
+      assert.deepStrictEqual(inspect(parser('&#X22;'), ctx), [['&'], '#X22;']);
+      assert.deepStrictEqual(inspect(parser('&#XD06;'), ctx), [['&'], '#XD06;']);
+      assert.deepStrictEqual(inspect(parser('&#xcab;'), ctx), [['&'], '#xcab;']);
+      assert.deepStrictEqual(inspect(parser(' &amp;'), ctx), undefined);
     });
 
     it('entity', () => {
-      assert.deepStrictEqual(inspect(parser('&NewLine;')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('&nbsp;')), [['\u00A0'], '']);
-      assert.deepStrictEqual(inspect(parser('&amp;')), [['&'], '']);
-      assert.deepStrictEqual(inspect(parser('&copy;')), [['©'], '']);
-      assert.deepStrictEqual(inspect(parser('&AElig;')), [['Æ'], '']);
-      assert.deepStrictEqual(inspect(parser('&Dcaron;')), [['Ď'], '']);
-      assert.deepStrictEqual(inspect(parser('&frac34;')), [['¾'], '']);
-      assert.deepStrictEqual(inspect(parser('&HilbertSpace;')), [['ℋ'], '']);
-      assert.deepStrictEqual(inspect(parser('&DifferentialD;')), [['ⅆ'], '']);
-      assert.deepStrictEqual(inspect(parser('&ClockwiseContourIntegral;')), [['∲'], '']);
-      assert.deepStrictEqual(inspect(parser('&ngE;')), [['≧̸'], '']);
+      assert.deepStrictEqual(inspect(parser('&NewLine;'), ctx), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser('&nbsp;'), ctx), [['\u00A0'], '']);
+      assert.deepStrictEqual(inspect(parser('&amp;'), ctx), [['&'], '']);
+      assert.deepStrictEqual(inspect(parser('&copy;'), ctx), [['©'], '']);
+      assert.deepStrictEqual(inspect(parser('&AElig;'), ctx), [['Æ'], '']);
+      assert.deepStrictEqual(inspect(parser('&Dcaron;'), ctx), [['Ď'], '']);
+      assert.deepStrictEqual(inspect(parser('&frac34;'), ctx), [['¾'], '']);
+      assert.deepStrictEqual(inspect(parser('&HilbertSpace;'), ctx), [['ℋ'], '']);
+      assert.deepStrictEqual(inspect(parser('&DifferentialD;'), ctx), [['ⅆ'], '']);
+      assert.deepStrictEqual(inspect(parser('&ClockwiseContourIntegral;'), ctx), [['∲'], '']);
+      assert.deepStrictEqual(inspect(parser('&ngE;'), ctx), [['≧̸'], '']);
     });
 
   });

package/src/parser/inline/htmlentity.ts

@@ -4,14 +4,20 @@ import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 export const unsafehtmlentity: UnsafeHTMLEntityParser = validate('&', focus(
-  /^&[0-9A-Za-z]{1,99};/,
+  /^&(?:[0-9A-Za-z]+;?)?/,
   //({ source }) => [[parser(source) ?? `${Command.Error}${source}`], '']));
-  ({ source }) => [[parser(source) ?? source], '']));
+  ({ context }) => {
+    const { source } = context;
+    context.position += source.length;
+    return source.length > 1 && source.at(-1) === ';'
+      ? [[parser(source) ?? source]]
+      : [[source]];
+  }));
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
   ([text]) => [
-    text.length === 1 || text[0] !== '&'
+    length === 1 || text.at(-1) !== ';'
       ? text
       : html('span', {
           class: 'invalid',