securemark 0.258.3 → 0.258.6

package/src/combinator/control/manipulation/indent.ts

@@ -21,7 +21,10 @@ export function indent<T>(opener: RegExp | Parser<T>, parser?: Parser<T> | boole
     ([indent]) => indent.length * 2 + +(indent[0] === ' '), [])), separation),
     (lines, rest, context) => {
       assert(parser = parser as Parser<T>);
+      const memo = context.memo;
+      memo && (memo.offset += rest.length);
       const result = parser(trimBlockEnd(lines.join('')), context);
+      memo && (memo.offset -= rest.length);
       return result && exec(result) === ''
         ? [eval(result), rest]
         : undefined;

package/src/combinator/data/parser/context/delimiter.ts

@@ -57,12 +57,15 @@ export class Delimiters {
   public match(source: string, precedence = 1): boolean {
     const { matchers } = this;
     for (let i = 0; i < matchers.length; ++i) {
-      switch (matchers[i][3](source)) {
+      const matcher = matchers[i];
+      if (precedence >= matcher[2]) continue;
+      switch (matcher[3](source)) {
         case true:
-          if (precedence < matchers[i][2]) return true;
-          continue;
+          return true;
         case false:
           return false;
+        default:
+          continue;
       }
     }
     return false;

package/src/combinator/data/parser/context/memo.ts

@@ -34,6 +34,6 @@ export class Memo {
     for (let i = position + this.offset, len = memory.length; i < len; ++i) {
       memory.pop();
     }
-    //console.log('clear', position);
+    //console.log('clear', position + 1);
   }
 }

package/src/combinator/data/parser/context.test.ts

@@ -10,27 +10,27 @@ describe('Unit: combinator/data/parser/context', () => {
 
   describe('reset', () => {
     const parser: Parser<number> = some(creation(
-      (s, context) => [[context.resources?.budget ?? NaN], s.slice(1)]));
+      (s, context) => [[context.resources?.clock ?? NaN], s.slice(1)]));
 
     it('root', () => {
-      const base: Context = { resources: { budget: 3, recursion: 1 } };
+      const base: Context = { resources: { clock: 3, recursion: 1 } };
       const ctx: Context = {};
       assert.deepStrictEqual(reset(base, parser)('123', ctx), [[3, 2, 1], '']);
-      assert(base.resources?.budget === 3);
-      assert(ctx.resources?.budget === undefined);
+      assert(base.resources?.clock === 3);
+      assert(ctx.resources?.clock === undefined);
       assert.throws(() => reset(base, parser)('1234', ctx));
-      assert(ctx.resources?.budget === undefined);
+      assert(ctx.resources?.clock === undefined);
       assert.deepStrictEqual(reset(base, parser)('123', ctx), [[3, 2, 1], '']);
     });
 
     it('node', () => {
-      const base: Context = { resources: { budget: 3, recursion: 1 } };
-      const ctx: Context = { resources: { budget: 1, recursion: 1 } };
+      const base: Context = { resources: { clock: 3, recursion: 1 } };
+      const ctx: Context = { resources: { clock: 1, recursion: 1 } };
       assert.deepStrictEqual(reset(base, parser)('1', ctx), [[1], '']);
-      assert(base.resources?.budget === 3);
-      assert(ctx.resources?.budget === 0);
+      assert(base.resources?.clock === 3);
+      assert(ctx.resources?.clock === 0);
       assert.throws(() => reset(base, parser)('1', ctx));
-      assert(ctx.resources?.budget === 0);
+      assert(ctx.resources?.clock === 0);
     });
 
   });
@@ -41,12 +41,12 @@ describe('Unit: combinator/data/parser/context', () => {
 
     it('', () => {
       const base: Context = { status: true };
-      const ctx: Context = { resources: { budget: 3, recursion: 1 } };
+      const ctx: Context = { resources: { clock: 3, recursion: 1 } };
       assert.deepStrictEqual(context(base, parser)('123', ctx), [[true, true, true], '']);
-      assert(ctx.resources?.budget === 0);
+      assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);
       assert.throws(() => reset(base, parser)('1', ctx));
-      assert(ctx.resources?.budget === 0);
+      assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);
     });
 

package/src/combinator/data/parser/context.ts

@@ -58,41 +58,31 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: [str
 
 export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, cost: number, parser: P): P;
 export function syntax<T>(syntax: number, precedence: number, cost: number, parser?: Parser<T>): Parser<T> {
-  return (source, context) => {
+  return creation(cost, (source, context) => {
     if (source === '') return;
     const memo = context.memo ??= new Memo();
     context.memorable ??= ~0;
     const p = context.precedence;
     context.precedence = precedence;
-    const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations');
-    if (resources.recursion <= 0) throw new Error('Too much recursion');
-    --resources.recursion;
-    const pos = source.length;
+    const position = source.length;
     const state = context.state ?? 0;
-    const cache = syntax && memo.get(pos, syntax, state);
+    const cache = syntax && memo.get(position, syntax, state);
     const result: Result<T> = cache
       ? cache.length === 0
         ? undefined
         : [cache[0], source.slice(cache[1])]
       : parser!(source, context);
-    ++resources.recursion;
-    if (result && !cache) {
-      resources.budget -= cost;
+    if (syntax && state & context.memorable!) {
+      cache ?? memo.set(position, syntax, state, eval(result), source.length - exec(result, '').length);
+      assert.deepStrictEqual(cache && cache, cache && memo.get(position, syntax, state));
     }
-    if (syntax) {
-      if (state & context.memorable!) {
-        cache ?? memo.set(pos, syntax, state, eval(result), source.length - exec(result, '').length);
-        assert.deepStrictEqual(cache && cache, cache && memo.get(pos, syntax, state));
-      }
-      else if (result && memo.length! >= pos) {
-        assert(!(state & context.memorable!));
-        memo.clear(pos);
-      }
+    if (result && !state && memo.length! >= position) {
+      assert(!(state & context.memorable!));
+      memo.clear(position);
     }
     context.precedence = p;
     return result;
-  };
+  });
 }
 
 export function creation<P extends Parser<unknown>>(parser: P): P;
@@ -101,14 +91,14 @@ export function creation(cost: number | Parser<unknown>, parser?: Parser<unknown
   if (typeof cost === 'function') return creation(1, cost);
   assert(cost >= 0);
   return (source, context) => {
-    const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations');
+    const { resources = { clock: 1, recursion: 1 } } = context;
+    if (resources.clock <= 0) throw new Error('Too many creations');
     if (resources.recursion <= 0) throw new Error('Too much recursion');
     --resources.recursion;
     const result = parser!(source, context);
     ++resources.recursion;
     if (result) {
-      resources.budget -= cost;
+      resources.clock -= cost;
     }
     return result;
   };
@@ -133,6 +123,24 @@ export function guard<T>(f: (context: Ctx) => boolean | number, parser: Parser<T
       : undefined;
 }
 
+export function constraint<P extends Parser<unknown>>(state: number, parser: P): P;
+export function constraint<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
+export function constraint<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
+  if (typeof positive === 'function') {
+    parser = positive;
+    positive = true;
+  }
+  assert(state);
+  return (source, context) => {
+    const s = positive
+      ? state & context.state!
+      : state & ~context.state!;
+    return s === state
+      ? parser!(source, context)
+      : undefined;
+  };
+}
+
 export function state<P extends Parser<unknown>>(state: number, parser: P): P;
 export function state<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
 export function state<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
@@ -140,6 +148,7 @@ export function state<T>(state: number, positive: boolean | Parser<T>, parser?:
     parser = positive;
     positive = true;
   }
+  assert(state);
   return (source, context) => {
     const s = context.state ?? 0;
     context.state = positive

package/src/combinator/data/parser.ts

@@ -9,7 +9,7 @@ export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   | undefined;
 export interface Ctx {
   readonly resources?: {
-    budget: number;
+    clock: number;
     recursion: number;
   };
   precedence?: number;

package/src/parser/autolink.test.ts

@@ -13,13 +13,14 @@ describe('Unit: parser/autolink', () => {
       assert.deepStrictEqual(inspect(parser('@a#b')), [['<a href="/@a?ch=b" class="channel">@a#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a#b')), [['a#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0a#b')), [['0', 'a#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0a#b')), [['0a#b'], '']);
       assert.deepStrictEqual(inspect(parser('あ#b')), [['あ#b'], '']);
       assert.deepStrictEqual(inspect(parser('あい#b')), [['あ', 'い#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあ#b')), [['0a', 'あ#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあ#b')), [['0aあ#b'], '']);
       assert.deepStrictEqual(inspect(parser('0aあい#b')), [['0a', 'あ', 'い#b'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b')), [['a', '<br>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '\\', '<br>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('0a>>b')), [['0a>>b'], '']);
     });
 
   });

package/src/parser/autolink.ts

@@ -5,7 +5,23 @@ import { linebreak, unescsource } from './source';
 
 export import AutolinkParser = MarkdownParser.AutolinkParser;
 
-export const autolink: AutolinkParser = lazy(() => union([
+const delimiter = /[@#>0-9A-Za-z\n]|\S[#>]/;
+
+export const autolink: AutolinkParser = (source, context) => {
+  if (source === '') return;
+  assert(source[0] !== '\x1B');
+  const i = source.search(delimiter);
+  switch (i) {
+    case -1:
+      return [[source], ''];
+    case 0:
+      return parser(source, context);
+    default:
+      return [[source.slice(0, i)], source.slice(i)];
+  }
+};
+
+const parser: AutolinkParser = lazy(() => union([
   autolink_,
   linebreak,
   unescsource

package/src/parser/block/extension/table.ts

@@ -228,7 +228,7 @@ function format(rows: Tree<RowParser>[]): HTMLTableSectionElement[] {
         : cells[j];
       const isHeadCell = cell.tagName === 'TH';
       heads |= BigInt(isHeadCell) << jn;
-      highlights |= BigInt(cell.classList.contains('highlight')) << jn;
+      highlights |= BigInt(cell.className === 'highlight') << jn;
       hasDataCell ||= !isHeadCell;
       if (isHeadCell && !hasDataCell) {
         lHeadCellIdx = jn;

package/src/parser/block/olist.ts

@@ -115,7 +115,7 @@ function initial(type: string): RegExp {
 }
 
 function format(el: HTMLOListElement, type: string, form: string): HTMLOListElement {
-  if (el.firstElementChild?.firstElementChild?.classList.contains('checkbox')) {
+  if (el.firstElementChild?.firstElementChild?.className === 'checkbox') {
     el.setAttribute('class', 'checklist');
   }
   define(el, {

package/src/parser/block/paragraph.test.ts

@@ -45,13 +45,15 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('>>11 a')), [['<p><a href="?at=11" class="anchor">&gt;&gt;11</a> a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('>>>11 a')), [['<p>&gt;<a href="?at=11" class="anchor">&gt;&gt;11</a> a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('>> a\n>>1')), [['<p>&gt;&gt; a<br><a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
-      assert.deepStrictEqual(inspect(parser('a>>1')), [['<p>a<a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
+      assert.deepStrictEqual(inspect(parser('a>>1')), [['<p>a&gt;&gt;1</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('ab>>1')), [['<p>ab&gt;&gt;1</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a >>1')), [['<p>a <a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\n>>1')), [['<p>a<br><a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\n>>1\nb')), [['<p>a<br><a href="?at=1" class="anchor">&gt;&gt;1</a><br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\n>> b\nc')), [['<p>a<br>&gt;&gt; b<br>c</p>'], '']);
       assert.deepStrictEqual(inspect(parser('\t>>1')), [['<p>\t<a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
       assert.deepStrictEqual(inspect(parser('\t>>>1')), [['<p>\t&gt;<a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
+      assert.deepStrictEqual(inspect(parser('あ>>1')), [['<p>あ<a href="?at=1" class="anchor">&gt;&gt;1</a></p>'], '']);
     });
 
     it('comment', () => {

package/src/parser/block/reply/quote.ts

@@ -57,8 +57,8 @@ const qblock: ReplyParser.QuoteParser.BlockParser = (source, context) => {
       ++i;
       continue;
     }
-    if (child.classList.contains('cite') || child.classList.contains('quote')) {
-      context.resources && (context.resources.budget -= child.childNodes.length);
+    if (child.className === 'cite' || child.classList.contains('quote')) {
+      context.resources && (context.resources.clock -= child.childNodes.length);
       nodes.splice(i, 1, ...child.childNodes as NodeListOf<HTMLElement>);
       --i;
       continue;

package/src/parser/block/table.ts

@@ -61,7 +61,7 @@ const data: CellParser.DataParser = creation(fmap(
   ns => [html('td', trimNode(defrag(ns)))]));
 
 function format(rows: HTMLTableRowElement[]): HTMLTableRowElement[] {
-  const aligns = rows[0].classList.contains('invalid')
+  const aligns = rows[0].className === 'invalid'
     ? []
     : duffReduce(rows.shift()!.children, (acc, el) => push(acc, [el.textContent!]), [] as string[]);
   for (let i = 0; i < rows.length; ++i) {

package/src/parser/block/ulist.ts

@@ -26,11 +26,11 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
   ])))),
   es => [format(html('ul', es))])));
 
-export const checkbox = focus(
+export const checkbox = creation(focus(
   /^\[[xX ]\](?=$|\s)/,
   source => [[
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
-  ], '']);
+  ], '']));
 
 export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | string)[] {
   return ns.length === 1
@@ -41,7 +41,7 @@ export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | stri
 }
 
 function format(el: HTMLUListElement): HTMLUListElement {
-  if (el.firstElementChild?.firstElementChild?.classList.contains('checkbox')) {
+  if (el.firstElementChild?.firstElementChild?.className === 'checkbox') {
     el.setAttribute('class', 'checklist');
   }
   return el;

package/src/parser/block.ts

@@ -36,7 +36,7 @@ export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
 export const block: BlockParser = creation(error(
-  reset({ resources: { budget: 50 * 1000, recursion: 20 } },
+  reset({ resources: { clock: 50 * 1000, recursion: 20 } },
   union([
     emptyline,
     horizontalrule,

package/src/parser/inline/annotation.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
-import { union, some, guard, context, syntax, state, surround, lazy } from '../../combinator';
+import { union, some, context, syntax, constraint, state, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
 import { Syntax, State } from '../context';
@@ -9,7 +9,7 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => surround(
   '((',
-  guard(context => ~context.state! & State.annotation,
+  constraint(State.annotation, false,
   syntax(Syntax.annotation, 6, 1,
   state(State.annotation | State.media,
   startLoose(
@@ -18,4 +18,4 @@ export const annotation: AnnotationParser = lazy(() => surround(
   '))',
   false,
   ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNode(defrag(ns)))])], rest],
-  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest, next)));
+  ([, ns, rest], next, context) => next[0] === ')' ? undefined : optimize('((', ns, rest, next, context)));

package/src/parser/inline/autolink/email.test.ts

@@ -20,9 +20,9 @@ describe('Unit: parser/inline/autolink/email', () => {
       assert.deepStrictEqual(inspect(parser('a@b#1')), [['a@b#1'], '']);
       assert.deepStrictEqual(inspect(parser('a@@')), [['a@@'], '']);
       assert.deepStrictEqual(inspect(parser('a@@b')), [['a@@b'], '']);
-      assert.deepStrictEqual(inspect(parser('a+@b')), undefined);
-      assert.deepStrictEqual(inspect(parser('a..b@c')), undefined);
-      assert.deepStrictEqual(inspect(parser('a++b@c')), undefined);
+      assert.deepStrictEqual(inspect(parser('a+@b')), [['a'], '+@b']);
+      assert.deepStrictEqual(inspect(parser('a..b@c')), [['a'], '..b@c']);
+      assert.deepStrictEqual(inspect(parser('a++b@c')), [['a'], '++b@c']);
       assert.deepStrictEqual(inspect(parser(`a@${'b'.repeat(64)}`)), [[`a@${'b'.repeat(64)}`], '']);
       assert.deepStrictEqual(inspect(parser(' a@b')), undefined);
     });

package/src/parser/inline/autolink/url.test.ts

@@ -8,12 +8,12 @@ describe('Unit: parser/inline/autolink/url', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser('http')), undefined);
-      assert.deepStrictEqual(inspect(parser('ttp')), undefined);
-      assert.deepStrictEqual(inspect(parser('http://')), undefined);
-      assert.deepStrictEqual(inspect(parser('http://[')), undefined);
-      assert.deepStrictEqual(inspect(parser('http://]')), undefined);
-      assert.deepStrictEqual(inspect(parser('Http://host')), undefined);
+      assert.deepStrictEqual(inspect(parser('http')), [['http'], '']);
+      assert.deepStrictEqual(inspect(parser('ttp')), [['ttp'], '']);
+      assert.deepStrictEqual(inspect(parser('http://')), [['http'], '://']);
+      assert.deepStrictEqual(inspect(parser('http://[')), [['http'], '://[']);
+      assert.deepStrictEqual(inspect(parser('http://]')), [['http'], '://]']);
+      assert.deepStrictEqual(inspect(parser('Http://host')), [['Http'], '://host']);
       //assert.deepStrictEqual(inspect(parser('http://[::ffff:0:0%1]')), [['<a class="invalid">http://[::ffff:0:0%1]</a>'], '']);
       //assert.deepStrictEqual(inspect(parser('http://[::ffff:0:0/96]')), [['<a class="invalid">http://[::ffff:0:0/96]</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' http://a')), undefined);

package/src/parser/inline/autolink.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../inline';
-import { union, some, syntax, guard, validate, fmap } from '../../combinator';
+import { union, some, syntax, constraint, validate, fmap } from '../../combinator';
 import { url } from './autolink/url';
 import { email } from './autolink/email';
 import { channel } from './autolink/channel';
@@ -12,14 +12,14 @@ import { Syntax, State } from '../context';
 import { stringify } from '../util';
 
 export const autolink: AutolinkParser = fmap(
-  validate(/^(?:[@#>0-9A-Za-z]|\S#)/,
-  guard(context => ~context.state! & State.autolink,
+  validate(/^(?:[@#>0-9A-Za-z]|\S[#>])/,
+  constraint(State.autolink, false,
   syntax(Syntax.autolink, 1, 1,
   some(union([
     url,
     email,
     // Escape unmatched email-like strings.
-    str(/^[0-9A-Za-z]+(?:[.+_-][0-9A-Za-z]+)*(?:@(?:[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?)+/),
+    str(/^[0-9A-Za-z]+(?:[.+_-][0-9A-Za-z]+)*(?:@(?:[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?)*/),
     channel,
     account,
     // Escape unmatched account-like strings.

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

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, some, syntax, creation, precedence, guard, state, validate, surround, open, lazy, fmap } from '../../../combinator';
+import { union, some, syntax, creation, precedence, constraint, state, validate, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str, stropt } from '../../source';
@@ -12,7 +12,7 @@ import IndexParser = ExtensionParser.IndexParser;
 
 export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surround(
   '[#',
-  guard(context => ~context.state! & State.index,
+  constraint(State.index, false,
   syntax(Syntax.index, 2, 1,
   state(State.annotation | State.reference | State.index | State.label | State.link | State.media | State.autolink,
   startTight(

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

@@ -1,6 +1,6 @@
 import { Array } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, guard, creation, validate, surround, clear, fmap } from '../../../combinator';
+import { union, constraint, creation, validate, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { State } from '../../context';
 import { html } from 'typed-dom/dom';
@@ -13,7 +13,7 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(validate
 ])));
 
 export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creation(fmap(
-  guard(context => ~context.state! & State.label,
+  constraint(State.label, false,
   union([
     surround('[', body, ']'),
     body,

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

@@ -21,10 +21,10 @@ describe('Unit: parser/inline/html', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
       assert.deepStrictEqual(inspect(parser('<0>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<aT>')), 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>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<T>')), [['<span class="invalid">&lt;T&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>'], '']);
@@ -39,8 +39,8 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdi>\\\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;<span class="linebreak"> </span>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</BDO>')), [['<span class="invalid">&lt;bdi&gt;a&lt;/BDO&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<BDI>a</BDI>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<BDI>a</bdo>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<BDI>a</BDI>')), [['<span class="invalid">&lt;BDI&gt;a&lt;/BDI&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<BDI>a</bdo>')), [['<span class="invalid">&lt;BDI&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('</bdi>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdi/>')), undefined);
       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>'], '']);
@@ -87,9 +87,9 @@ describe('Unit: parser/inline/html', () => {
       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>')), [['<img'], '>']);
-      assert.deepStrictEqual(inspect(parser('<bdi><img></bdi>')), [['<bdi>&lt;img&gt;</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<img />')), [['<img'], ' />']);
+      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('<img />')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdi><img /></bdi>')), [['<bdi>&lt;img /&gt;</bdi>'], '']);
     });
 
@@ -100,15 +100,15 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>')), [['<bdi>a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi __proto__>a</bdi>')), undefined);
       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>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdi X>a</bdi>')), undefined);
+      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>')), undefined);
       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>')), undefined);
-      assert.deepStrictEqual(inspect(parser('<bdo X>a</bdo>')), undefined);
+      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>')), undefined);
@@ -116,16 +116,16 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdo dir=">a</bdo>')), undefined);
       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>')), undefined);
+      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 >')), [['<wbr'], ' >']);
-      assert.deepStrictEqual(inspect(parser('<wbr constructor>')), [['<wbr'], ' constructor>']);
-      assert.deepStrictEqual(inspect(parser('<wbr X>')), [['<wbr'], ' X>']);
-      assert.deepStrictEqual(inspect(parser('<wbr x>')), [['<wbr'], ' x>']);
+      assert.deepStrictEqual(inspect(parser('<wbr >')), [['<wbr>'], '']);
+      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>'], '']);
     });
 
   });

package/src/parser/inline/html.ts

@@ -19,14 +19,15 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, syntax(Syntax.none, 5, 1, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, syntax(Syntax.none, 5, 1, union([
   focus(
-    '<wbr>',
+    /^<wbr[^\S\n]*>/i,
     () => [[h('wbr')], '']),
-  focus(
+  surround(
     // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-    /^<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/,
-    source => [[source], '']),
+    str(/^<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/i), some(union([attribute])), str(/^[^\S\n]*>/), true,
+    ([as, bs = [], cs], rest) =>
+      [[elem(as[0].slice(1), push(unshift(as, bs), cs), [], [])], rest]),
   match(
     new RegExp(String.raw`^<(${TAGS.join('|')})(?=[^\S\n]|>)`),
     memoize(
@@ -44,7 +45,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
           [[elem(tag, as, bs, [])], rest]),
     ([, tag]) => TAGS.indexOf(tag), [])),
   match(
-    /^<([a-z]+)(?=[^\S\n]|>)/,
+    /^<([a-z]+)(?=[^\S\n]|>)/i,
     memoize(
     ([, tag]) =>
       surround<HTMLParser.TagParser, string>(surround(
@@ -62,8 +63,8 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
     new Cache(10000))),
 ])))));
 
-export const attribute: HTMLParser.TagParser.AttributeParser = union([
-  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/),
+export const attribute: HTMLParser.AttributeParser = union([
+  str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/i),
 ]);
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element