securemark 0.298.2 → 0.298.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.298.2",
+  "version": "0.298.3",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/combinator/control/constraint/line.ts

@@ -27,7 +27,7 @@ export function firstline(source: string, position: number): string {
     : source.slice(position, i + 1);
 }
 
-const emptyline = /[^\S\n]*(?:$|\n)/y;
+const emptyline = /[^\S\r\n]*(?:$|\r?\n)/y;
 export function isEmptyline(source: string, position: number): boolean {
   emptyline.lastIndex = position;
   return source.length === position

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

@@ -5,7 +5,7 @@ export function match<P extends Parser>(pattern: RegExp, f: (matched: RegExpMatc
 export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<N>): Parser<N> {
   assert(!pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^'));
   const count = typeof pattern === 'object'
-    ? /[^^\\*+][*+]/.test(pattern.source)
+    ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
     : false;
   return failsafe(input => {
     const context = input;

package/src/combinator/data/delimiter.ts

@@ -4,30 +4,43 @@ import { consume } from './parser/context';
 interface Delimiter {
   readonly memory: Delimiter[];
   readonly index: number;
-  readonly signature: number | string;
-  readonly matcher: (input: Input) => boolean | undefined;
+  readonly tester: (input: Input) => boolean | undefined;
   readonly precedence: number;
   state: boolean;
 }
 
+const indexes = new Map();
+function index(source: string): number {
+  let x = 0;
+  for (let i = 0; i < source.length; ++i) {
+    const c = source.charCodeAt(i);
+    x = x ^ c << 1 || ~x ^ c << 1; // 16+1bit
+    assert(x !== 0);
+    x ^= x << 13; // shift <= 32-17bit
+    x ^= x >>> 17;
+    x ^= x << 15;
+  }
+  x >>>= 3;
+  x &= ~0 >>> 32 - 4;
+  assert(x !== 0);
+  assert(indexes.has(source) ? indexes.get(source) === x : indexes.set(source, x));
+  return x;
+}
+
 export class Delimiters {
   // 手間を惜しまなければ規定のパターンはすべて配列のインデクスに変換可能。
-  public static signature(pattern: string | RegExp | undefined): number | string {
+  public static signature(pattern: undefined | string | RegExp): number {
     switch (typeof pattern) {
       case 'undefined':
-        return 1 << 7;
+        return 0;
       case 'string':
-        assert(pattern !== '\x00');
-        if (pattern.length === 1) {
-          const code = pattern.charCodeAt(0);
-          return code;
-        }
-        return `s:${pattern}`;
+        assert(pattern !== '');
+        return index(`'${pattern}`);
       case 'object':
-        return `r/${pattern.source}`;
+        return index(`/${pattern.source}`);
     }
   }
-  public static matcher(pattern: string | RegExp | undefined, after?: string | RegExp): (input: Input<Context>) => true | undefined {
+  public static tester(pattern: string | RegExp | undefined, after?: string | RegExp): (input: Input<Context>) => true | undefined {
     switch (typeof pattern) {
       case 'undefined':
         return () => undefined;
@@ -40,27 +53,20 @@ export class Delimiters {
           : input => test(input) !== undefined || undefined;
     }
   }
-  private readonly tree: Record<number, Delimiter[]> = {};
-  private readonly map: Map<string, Delimiter[]> = new Map();
-  private registry(signature: number | string): Delimiter[] {
-    if (typeof signature === 'number') {
-      return this.tree[signature] ??= [];
-    }
-    else {
-      const ds = this.map.get(signature);
-      if (ds) return ds;
-      const blank: Delimiter[] = [];
-      this.map.set(signature, blank);
-      return blank;
-    }
+  private readonly memories: Delimiter[][] = [];
+  private registry(signature: number): Delimiter[] {
+    assert(signature >= 0);
+    assert(signature >>> 0 === signature);
+    assert(signature >>> 16 === 0);
+    return this.memories[signature] ??= [];
   }
   private readonly delimiters: Delimiter[] = [];
   private readonly stack: number[] = [];
   private readonly states: (readonly number[])[] = [];
   public push(
     delims: readonly {
-      readonly signature: number | string;
-      readonly matcher: (input: Input) => boolean | undefined;
+      readonly signature: number;
+      readonly tester: (input: Input) => boolean | undefined;
       readonly precedence: number;
     }[]
   ): void {
@@ -68,7 +74,7 @@ export class Delimiters {
     // シグネチャ数以下
     assert(delimiters.length < 100);
     for (let i = 0; i < delims.length; ++i) {
-      const { signature, matcher, precedence } = delims[i];
+      const { signature, tester, precedence } = delims[i];
       const memory = this.registry(signature);
       const index = memory[0]?.index ?? delimiters.length;
       assert(memory.length === 0 || precedence === delimiters[index].precedence);
@@ -76,8 +82,7 @@ export class Delimiters {
         const delimiter: Delimiter = {
           memory,
           index,
-          signature,
-          matcher,
+          tester,
           precedence,
           state: true,
         };
@@ -86,10 +91,10 @@ export class Delimiters {
         stack.push(index);
       }
       else {
+        // 現状各優先順位は固定
+        assert(memory.length === 1);
         stack.push(-1);
       }
-      // 現状各優先順位は固定
-      assert(memory.length === 1);
     }
   }
   public pop(count: number): void {
@@ -121,7 +126,7 @@ export class Delimiters {
       const delimiter = delimiters[i];
       if (delimiter.precedence >= precedence || !delimiter.state) continue;
       delimiter.state = false;
-      indexes.push(i)
+      indexes.push(i);
     }
     this.states.push(indexes);
   }
@@ -132,13 +137,13 @@ export class Delimiters {
       delimiters[indexes[i]].state = true;
     }
   }
-  public match(input: Input): boolean {
+  public test(input: Input): boolean {
     const { precedence } = input;
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];
       if (delimiter.precedence <= precedence || !delimiter.state) continue;
-      switch (delimiter.matcher(input)) {
+      switch (delimiter.tester(input)) {
         case true:
           return true;
         case false:
@@ -154,7 +159,7 @@ export class Delimiters {
 export function matcher(pattern: string | RegExp, advance: boolean, after?: Parser<string>): Parser<string> {
   assert(pattern instanceof RegExp ? !pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^') : true);
   const count = typeof pattern === 'object'
-    ? /[^^\\*+][*+]/.test(pattern.source)
+    ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
     : false;
   switch (typeof pattern) {
     case 'string':
@@ -194,7 +199,7 @@ export function matcher(pattern: string | RegExp, advance: boolean, after?: Pars
 export function tester(pattern: string | RegExp, advance: boolean, after?: Parser<unknown>): Parser<never> {
   assert(pattern instanceof RegExp ? !pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^') : true);
   const count = typeof pattern === 'object'
-    ? /[^^\\*+][*+]/.test(pattern.source)
+    ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
     : false;
   switch (typeof pattern) {
     case 'string':

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

@@ -4,12 +4,14 @@ import { clone } from 'spica/assign';
 
 export function reset<P extends Parser>(base: Options, parser: P): P;
 export function reset<N>(base: Context, parser: Parser<N>): Parser<N> {
+  const clock = base.resources?.clock;
+  const recursions = base.resources?.recursions;
   return input => {
     const context = input;
     // @ts-expect-error
     context.resources ??= {
-      clock: base.resources?.clock,
-      recursions: base.resources?.recursions.slice(),
+      clock,
+      recursions: recursions?.slice(),
     };
     context.backtracks = {};
     return parser(input);

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

@@ -10,7 +10,7 @@ export function inits<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context,
     let nodes: List<Node<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) break;
-      if (context.delimiters.match(input)) break;
+      if (context.delimiters.test(input)) break;
       const result = parsers[i](input);
       if (result === undefined) break;
       nodes = nodes?.import(result) ?? result;

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

@@ -10,7 +10,7 @@ export function sequence<N, D extends Parser<N>[]>(parsers: D): Parser<N, Contex
     let nodes: List<Node<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) return;
-      if (context.delimiters.match(input)) return;
+      if (context.delimiters.test(input)) return;
       const result = parsers[i](input);
       if (result === undefined) return;
       nodes = nodes?.import(result) ?? result;

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

@@ -21,10 +21,11 @@ export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp
     after = undefined;
   }
   assert(parser);
-  const match = Delimiters.matcher(delimiter as string, after as string);
+  assert(delimiter !== '');
+  const match = Delimiters.tester(delimiter as string, after as string);
   const delims = delimiters?.map(([delimiter, precedence]) => ({
     signature: Delimiters.signature(delimiter),
-    matcher: Delimiters.matcher(delimiter),
+    tester: Delimiters.tester(delimiter),
     precedence,
   }));
   return input => {
@@ -36,7 +37,7 @@ export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp
     // whileは数倍遅い
     for (const len = source.length; context.position < len;) {
       if (match(input)) break;
-      if (context.delimiters.match(input)) break;
+      if (context.delimiters.test(input)) break;
       const result = parser(input);
       if (result === undefined) break;
       nodes = nodes?.import(result) ?? result;

package/src/parser/api/bind.ts

@@ -3,7 +3,6 @@ import { Context, Segment } from '../context';
 import { input } from '../../combinator/data/parser';
 import { segment } from '../segment';
 import { block } from '../block';
-import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
 import { note } from '../processor/note';
@@ -42,13 +41,12 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   function* parse(source: string): Generator<Progress, undefined, undefined> {
     if (settings.chunk && revision) throw new Error('Chunks cannot be updated');
     const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
-    source = normalize(source);
     // @ts-expect-error
     context.url = url ? new ReadonlyURL(url as ':') : undefined;
     const rev = revision = Symbol();
     const sourceSegments: string[] = [];
     const sourceSegmentAttrs: Segment[] = [];
-    for (const [seg, attr] of segment(source)) {
+    for (const [seg, attr] of segment(source, !context.local)) {
       sourceSegments.push(seg);
       sourceSegmentAttrs.push(attr);
       yield { type: 'segment', value: seg };
@@ -76,15 +74,15 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     context.header = true;
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
-      const src = sourceSegments[index];
+      const seg = sourceSegments[index];
       context.segment = sourceSegmentAttrs[index] | Segment.write;
-      const es = block(input(src, new Context(context)))
-        ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? [];
+      const es = block(input(seg, new Context(context)))!
+        .foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []);
       // @ts-expect-error
       context.header = false;
       blocks.length === index
-        ? blocks.push([src, es, url])
-        : blocks.splice(index, 0, [src, es, url]);
+        ? blocks.push([seg, es, url])
+        : blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.
       // Therefore any `base` node will never be unavailable by deletions until all the dependent `el` nodes are added.

package/src/parser/api/header.ts

@@ -8,7 +8,7 @@ export function header(source: string): string {
 
 export function headers(source: string): string[] {
   const [el] = parse(source);
-  return el?.textContent!.trimEnd().slice(el.firstChild!.firstChild!.textContent!.length).split('\n') ?? [];
+  return el?.textContent!.trimEnd().slice(el.firstChild!.firstChild!.textContent!.length).split(/\r?\n/) ?? [];
 }
 
 function parse(source: string): [HTMLElement, number] | [] {

package/src/parser/api/parse.ts

@@ -3,7 +3,6 @@ import { input } from '../../combinator/data/parser';
 import { Context, Segment } from '../context';
 import { segment } from '../segment';
 import { block } from '../block';
-import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
 import { note } from '../processor/note';
@@ -17,7 +16,6 @@ interface Options extends ParserOptions {
 
 export function parse(source: string, options: Options = {}, context?: Context): DocumentFragment {
   const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
-  source = !context ? normalize(source) : source;
   context = new Context({
     host: options.host ?? context?.host ?? new ReadonlyURL(location.pathname, location.origin),
     url: url ? new ReadonlyURL(url as ':') : context?.url,
@@ -34,13 +32,14 @@ export function parse(source: string, options: Options = {}, context?: Context):
   const node = frag();
   // @ts-expect-error
   context.header = true;
-  for (const [seg, attr] of segment(source)) {
+  for (const [seg, attr] of segment(source, !context.local)) {
     context.segment = attr | Segment.write;
-    node.append(
-      ...block(input(seg, new Context(context)))
-        ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);
+    const es = block(input(seg, new Context(context)))!
+      .foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, [])
     // @ts-expect-error
     context.header = false;
+    if (es.length === 0) continue;
+    node.append(...es);
   }
   assert(options.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
   if (options.test) return node;

package/src/parser/block/codeblock.ts

@@ -5,7 +5,7 @@ import { autolink } from '../autolink';
 import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-const opener = /(`{3,})(?!`)([^\n]*)(?:$|\n)/y;
+const opener = /(`{3,})(?!`)([^\r\n]*)(?:$|\r?\n)/y;
 const language = /^[0-9a-z]+(?:-[a-z][0-9a-z]*)*$/i;
 
 export const segment: CodeBlockParser.SegmentParser = block(

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

@@ -15,7 +15,7 @@ import FigParser = ExtensionParser.FigParser;
 
 export const segment: FigParser.SegmentParser = block(
   sequence([
-    line(close(seg_label, /(?!\S).*\n/y)),
+    line(close(seg_label, /(?!\S).*\r?\n/y)),
     union([
       seg_code,
       seg_math,

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

@@ -24,7 +24,7 @@ import FigureParser = ExtensionParser.FigureParser;
 export const segment: FigureParser.SegmentParser = block(match(
   /(~{3,})(?:figure )?(?=\[?\$)/y,
   memoize(
-  ([, fence], closer = new RegExp(String.raw`${fence}[^\S\n]*(?:$|\n)`, 'y')) => close(
+  ([, fence], closer = new RegExp(String.raw`${fence}[^\S\r\n]*(?:$|\r?\n)`, 'y')) => close(
     sequence([
       contentline,
       inits([

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

@@ -56,7 +56,7 @@ export const message: MessageParser = block(fmap(
           class: `message`,
           'data-type': type,
         },
-        [...segment(body)].reduce(
+        [...segment(body, false)].reduce(
           (acc, [seg]) =>
             push(acc, unwrap(content(subinput(seg, context)))),
           [html('h1', title(type))])))

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

@@ -4,7 +4,7 @@ import { block, fence, clear, fmap } from '../../../combinator';
 import { unwrap, invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
-const opener = /(~{3,})(?!~)[^\n]*(?:$|\n)/y;
+const opener = /(~{3,})(?!~)[^\r\n]*(?:$|\r?\n)/y;
 
 export const segment: ExtensionParser.PlaceholderParser.SegmentParser = block(
   clear(fence(opener, 300)));

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

@@ -14,7 +14,7 @@ import RowParser = TableParser.RowParser;
 import AlignParser = TableParser.AlignParser;
 import CellParser = TableParser.CellParser;
 
-const opener = /(~{3,})table(?:\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/y;
+const opener = /(~{3,})table(?:\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y;
 
 export const segment: TableParser.SegmentParser = block(
   clear(fence(opener, 10000)));

package/src/parser/block/heading.ts

@@ -9,7 +9,7 @@ import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(focus(
-  /#+ +\S[^\n]*(?:\n#+(?=$|[ \n])[^\n]*)*(?:$|\n)/y,
+  /#+ +\S[^\r\n]*(?:\r?\n#+(?=$| |\r?\n)[^\r\n]*)*(?:$|\r?\n)/y,
   input => {
     const context = input;
     const { source, range } = context;

package/src/parser/block/mathblock.ts

@@ -4,7 +4,7 @@ import { block, fence, clear, fmap } from '../../combinator';
 import { unwrap, invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-const opener = /(\${2,})(?!\$)([^\n]*)(?:$|\n)/y;
+const opener = /(\${2,})(?!\$)([^\r\n]*)(?:$|\r?\n)/y;
 
 export const segment: MathBlockParser.SegmentParser = block(
   clear(fence(opener, 300)));

package/src/parser/block.ts

@@ -58,7 +58,6 @@ export const block: BlockParser = reset(
         20 || Recursion.terminal,
       ],
     },
-    backtracks: {},
   },
   error(union([
     emptysegment,
@@ -73,8 +72,8 @@ export const block: BlockParser = reset(
         case Segment.figure:
           return figure(input);
       }
-      const fst = source[position];
-      switch (fst) {
+      const char = source[position];
+      switch (char) {
         case Command.Error:
           throw new Error(firstline(source, position + 1).trimEnd());
         case '=':
@@ -117,14 +116,14 @@ export const block: BlockParser = reset(
         case '(':
           return olist(input);
         default:
-          if ('0' <= fst && fst <= '9') return olist(input);
+          if ('0' <= char && char <= '9') return olist(input);
       }
     },
     paragraph
   ])));
 
 function error(parser: BlockParser): BlockParser {
-  const reg = new RegExp(String.raw`^${Command.Error}[^\n]*\n`)
+  const reg = new RegExp(String.raw`^${Command.Error}[^\r\n]*\r?\n`)
   return recover<BlockParser>(
     parser,
     ({ source, position, id }, reason) => new List([

package/src/parser/header.test.ts

@@ -27,6 +27,7 @@ describe('Unit: parser/header', () => {
       assert.deepStrictEqual(inspect(parser, input('---\na: b\n---', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
       assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
       assert.deepStrictEqual(inspect(parser, input('---\na: b\nC: D e\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\r\na: b\r\nC: D e\r\n---\r\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
       assert.deepStrictEqual(inspect(parser, input('----\na: b\n----', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
     });
 

package/src/parser/header.ts

@@ -7,12 +7,12 @@ import { normalize } from './api/normalize';
 import { html, defrag } from 'typed-dom/dom';
 
 export const header: MarkdownParser.HeaderParser = lazy(() => validate(
-  /---+[^\S\n]*\n(?=\S)/y,
+  /---+[^\S\r\n]*\r?\n(?=\S)/y,
   inits([
     block(
       union([
         validate(context => context.header,
-        focus(/(---+)[^\S\n]*\n(?:[a-z][0-9a-z]*(?:-[0-9a-z]+)*:[ \t]+\S[^\n]*\n){1,100}\1[^\S\n]*(?:$|\n)/yi,
+        focus(/(---+)[^\S\r\n]*\r?\n(?:[a-z][0-9a-z]*(?:-[0-9a-z]+)*:[ \t]+\S[^\r\n]*\r?\n){1,100}\1[^\S\r\n]*(?:$|\r?\n)/yi,
         convert(source =>
           normalize(source.slice(source.indexOf('\n') + 1, source.trimEnd().lastIndexOf('\n'))),
           fmap(
@@ -36,7 +36,7 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
           ]);
         },
       ])),
-    clear(str(/[^\S\n]*\n/y)),
+    clear(str(/[^\S\r\n]*\r?\n/y)),
   ])));
 
 const field: MarkdownParser.HeaderParser.FieldParser = line(({ source, position }) => {

package/src/parser/inline/autolink.ts

@@ -14,8 +14,8 @@ export const autolink: AutolinkParser = lazy(() =>
   input => {
     const { source, position } = input;
     if (position === source.length) return;
-    const fst = source[position];
-    switch (fst) {
+    const char = source[position];
+    switch (char) {
       case '@':
         return account(input);
       case '#':
@@ -41,6 +41,6 @@ export const autolink: AutolinkParser = lazy(() =>
         }
         return url(input) || email(input);
       default:
-        if (isAlphanumeric(fst)) return email(input);
+        if (isAlphanumeric(char)) return email(input);
     }
   }));

package/src/parser/inline/bracket.ts

@@ -8,19 +8,18 @@ import { str } from '../source';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const indexA = /[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/y;
+export const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
 const indexF = new RegExp(
   indexA.source.replace(', ', '[，、]')
     .replace(/[09AZaz.]|\-(?!\w)/g, c => String.fromCodePoint(c.codePointAt(0)! + 0xFEE0)),
-  'y');
+  '');
 export function bracketname(context: Context, syntax: RegExp, opener: number, closer: number): string {
   const { source, position, range, linebreak } = context;
   syntax.lastIndex = position - range + opener;
   return range - opener - closer === 0
-      || linebreak === 0
-      && range - opener - closer <= 16
-      && syntax.test(source)
-      && syntax.lastIndex === position - closer
+      || linebreak === 0 &&
+         range - opener - closer <= 16 &&
+         syntax.test(source.slice(position - range + opener, position - closer))
     ? 'paren'
     : 'bracket';
 }

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

@@ -1,4 +1,4 @@
-import { html } from './html';
+import { html, TAGS } from './html';
 import { some } from '../../combinator';
 import { input } from '../../combinator/data/parser';
 import { Context } from '../context';
@@ -8,6 +8,10 @@ describe('Unit: parser/inline/html', () => {
   describe('html', () => {
     const parser = some(html);
 
+    it('hash', () => {
+      assert(TAGS.every(tag => parser(input(`<${tag}>`, new Context()))));
+    });
+
     it('xss', () => {
       assert.deepStrictEqual(inspect(parser, input('<script>', new Context())), [['<span class="invalid">&lt;script&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('<script>alert()<script>', new Context())), [['<span class="invalid">&lt;script&gt;alert()&lt;script&gt;</span>'], '']);