securemark 0.279.1 → 0.280.0

package/markdown.d.ts

@@ -784,8 +784,8 @@ export namespace MarkdownParser {
         // [#index|signature]
         Inline<'extension/index'>,
         Parser<HTMLAnchorElement, Context, [
-          IndexParser.SignatureParser,
           InlineParser,
+          IndexParser.SignatureParser,
         ]> {
       }
       export namespace IndexParser {

package/package.json

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

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

@@ -1,5 +1,12 @@
 import { memoize, reduce } from 'spica/memoize';
 
+interface Delimiter {
+  readonly index: number;
+  readonly signature: string;
+  readonly matcher: (source: string) => boolean | undefined;
+  readonly precedence: number;
+}
+
 export class Delimiters {
   public static signature(pattern: string | RegExp | undefined): string {
     switch (typeof pattern) {
@@ -23,43 +30,64 @@ export class Delimiters {
       }
     },
     this.signature);
-  private readonly matchers: [number, string, number, (source: string) => boolean | undefined][] = [];
-  private readonly registry: Record<string, boolean> = {};
-  private length = 0;
+  private readonly registry = memoize<(signature: string) => Delimiter[]>(() => []);
+  private readonly delimiters: Delimiter[] = [];
+  private readonly order: number[] = [];
   public push(
-    ...delimiters: readonly {
+    ...delims: readonly {
       readonly signature: string;
       readonly matcher: (source: string) => boolean | undefined;
       readonly precedence?: number;
     }[]
   ): void {
-    for (let i = 0; i < delimiters.length; ++i) {
-      const delimiter = delimiters[i];
-      assert(this.length >= this.matchers.length);
-      const { signature, matcher, precedence = 1 } = delimiter;
-      if (!this.registry[signature]) {
-        this.matchers.unshift([this.length, signature, precedence, matcher]);
-        this.registry[signature] = true;
+    const { registry, delimiters, order } = this;
+    for (let i = 0; i < delims.length; ++i) {
+      const { signature, matcher, precedence = 1 } = delims[i];
+      const stack = registry(signature);
+      const index = stack[0]?.index ?? delimiters.length;
+      if (stack.length === 0 || precedence > delimiters[index].precedence) {
+        const delimiter: Delimiter = {
+          index,
+          signature,
+          matcher,
+          precedence,
+        };
+        delimiters[index] = delimiter;
+        stack.push(delimiter);
+        order.push(index);
+      }
+      else {
+        order.push(-1);
       }
-      ++this.length;
     }
   }
   public pop(count = 1): void {
     assert(count > 0);
+    const { registry, delimiters, order } = this;
     for (let i = 0; i < count; ++i) {
-      assert(this.matchers.length > 0);
-      assert(this.length >= this.matchers.length);
-      if (--this.length === this.matchers[0][0]) {
-        this.registry[this.matchers.shift()![1]] = false;
+      assert(this.order.length > 0);
+      const index = order.pop()!;
+      if (index === -1) continue;
+      const stack = registry(delimiters[index].signature);
+      assert(stack.length > 0);
+      if (stack.length === 1) {
+        assert(index === delimiters.length - 1);
+        assert(stack[0] === delimiters.at(-1));
+        stack.pop();
+        delimiters.pop();
+      }
+      else {
+        stack.pop();
+        delimiters[index] = stack.at(-1)!;
       }
     }
   }
   public match(source: string, precedence = 1): boolean {
-    const { matchers } = this;
-    for (let i = 0; i < matchers.length; ++i) {
-      const matcher = matchers[i];
-      if (precedence >= matcher[2]) continue;
-      switch (matcher[3](source)) {
+    const { delimiters } = this;
+    for (let i = 0; i < delimiters.length; ++i) {
+      const delimiter = delimiters[i];
+      if (precedence >= delimiter.precedence) continue;
+      switch (delimiter.matcher(source)) {
         case true:
           return true;
         case false:

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

@@ -3,7 +3,7 @@ export class Memo {
     this.targets = targets;
   }
   public readonly targets: number;
-  private readonly memory: Record<string, readonly [any[], number] | readonly []>[/* pos */] = [];
+  private readonly memory: Record<number, Record<number, readonly [any[], number] | readonly []>>[/* pos */] = [];
   public get length(): number {
     return this.memory.length;
   }
@@ -12,8 +12,8 @@ export class Memo {
     syntax: number,
     state: number,
   ): readonly [any[], number] | readonly [] | undefined {
-    //console.log('get', position, syntax, state, this.memory[position - 1]?.[`${syntax}:${state}`]);;
-    const cache = this.memory[position - 1]?.[`${syntax}:${state}`];
+    //console.log('get', position, syntax, state, this.memory[position - 1]?.[syntax]?.[state]);
+    const cache = this.memory[position - 1]?.[syntax]?.[state];
     return cache?.length === 2
       ? [cache[0].slice(), cache[1]]
       : cache;
@@ -26,11 +26,11 @@ export class Memo {
     offset: number,
   ): void {
     const record = this.memory[position - 1] ??= {};
-    assert(!record[`${syntax}:${state}`]);
-    record[`${syntax}:${state}`] = nodes
+    assert(!record[syntax]?.[state]);
+    (record[syntax] ??= {})[state] = nodes
       ? [nodes.slice(), offset]
       : [];
-    //console.log('set', position, syntax, state, record[`${syntax}:${state}`]);
+    //console.log('set', position, syntax, state, record[syntax]?.[state]);
   }
   public clear(position: number): void {
     const memory = this.memory;

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

@@ -66,9 +66,9 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: read
   return result;
 }
 
-export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, cost: number, state: number, parser: P): P;
-export function syntax<T>(syntax: number, prec: number, cost: number, state: number, parser?: Parser<T>): Parser<T> {
-  return creation(cost, precedence(prec, ({ source, context }) => {
+export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, state: number, parser: P): P;
+export function syntax<T>(syntax: number, prec: number, state: number, parser?: Parser<T>): Parser<T> {
+  return precedence(prec, ({ source, context }) => {
     if (source === '') return;
     const memo = context.memo ??= new Memo();
     context.offset ??= 0;
@@ -91,7 +91,7 @@ export function syntax<T>(syntax: number, prec: number, cost: number, state: num
     }
     context.state = stateOuter;
     return result;
-  }));
+  });
 }
 
 export function creation<P extends Parser<unknown>>(parser: P): P;
@@ -100,11 +100,13 @@ export function creation<P extends Parser<unknown>>(cost: number, recursion: boo
 export function creation(cost: number | Parser<unknown>, recursion?: boolean | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
   if (typeof cost === 'function') return creation(1, true, cost);
   if (typeof recursion === 'function') return creation(cost, true, recursion);
-  assert(cost > 0);
+  assert(cost >= 0);
+  assert(recursion !== undefined);
   return ({ source, context }) => {
-    const resources = context.resources ?? { clock: 1, recursion: 1 };
+    assert([recursion = recursion!]);
+    const resources = context.resources ?? { clock: cost || 1, recursion: 1 };
     if (resources.clock <= 0) throw new Error('Too many creations');
-    if (resources.recursion <= 0) throw new Error('Too much recursion');
+    if (resources.recursion < +recursion) throw new Error('Too much recursion');
     recursion && --resources.recursion;
     const result = parser!({ source, context });
     recursion && ++resources.recursion;
@@ -171,3 +173,17 @@ export function state<T>(state: number, positive: boolean | Parser<T>, parser?:
     return result;
   };
 }
+
+//export function log<P extends Parser<unknown>>(log: number, parser: P, cond?: (ns: readonly Tree<P>[]) => boolean): P;
+//export function log<T>(log: number, parser: Parser<T>, cond: (ns: readonly T[]) => boolean = () => true): Parser<T> {
+//  assert(log);
+//  return ({ source, context }) => {
+//    const l = context.log ?? 0;
+//    context.log = 0;
+//    const result = parser!({ source, context });
+//    context.log = result && cond(eval(result))
+//      ? l | log
+//      : l;
+//    return result;
+//  };
+//}

package/src/parser/api/parse.test.ts

@@ -298,17 +298,17 @@ describe('Unit: parser/api/parse', () => {
 
     it('recursion', () => {
       assert.deepStrictEqual(
-        [...parse('{'.repeat(20)).children].map(el => el.outerHTML),
-        [`<p>${'{'.repeat(20)}</p>`]);
+        [...parse('{'.repeat(21)).children].map(el => el.outerHTML),
+        [`<p>${'{'.repeat(21)}</p>`]);
       assert.deepStrictEqual(
-        [...parse('{'.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse('{'.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
           '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
-          `<pre class="error" translate="no">${'{'.repeat(21)}</pre>`,
+          `<pre class="error" translate="no">${'{'.repeat(22)}</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse('('.repeat(20)).children].map(el => el.outerHTML),
-        [`<p>${'('.repeat(20)}</p>`]);
+        [...parse('('.repeat(21)).children].map(el => el.outerHTML),
+        [`<p>${'('.repeat(21)}</p>`]);
       assert.deepStrictEqual(
         [...parse('('.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
@@ -316,8 +316,8 @@ describe('Unit: parser/api/parse', () => {
           `<pre class="error" translate="no">${'('.repeat(22)}</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse('['.repeat(20)).children].map(el => el.outerHTML),
-        [`<p>${'['.repeat(20)}</p>`]);
+        [...parse('['.repeat(21)).children].map(el => el.outerHTML),
+        [`<p>${'['.repeat(21)}</p>`]);
       assert.deepStrictEqual(
         [...parse('['.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
@@ -325,8 +325,8 @@ describe('Unit: parser/api/parse', () => {
           `<pre class="error" translate="no">${'['.repeat(22)}</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse('['.repeat(17) + '\na').children].map(el => el.outerHTML),
-        [`<p>${'['.repeat(17)}<br>a</p>`]);
+        [...parse('['.repeat(20) + '\na').children].map(el => el.outerHTML),
+        [`<p>${'['.repeat(20)}<br>a</p>`]);
     });
 
     if (!navigator.userAgent.includes('Chrome')) return;
@@ -335,15 +335,15 @@ describe('Unit: parser/api/parse', () => {
       this.timeout(5000);
       // 実測500ms程度
       assert.deepStrictEqual(
-        [...parse('.'.repeat(50000)).children].map(el => el.outerHTML),
-        [`<p>${'.'.repeat(50000)}</p>`]);
+        [...parse('.'.repeat(20000)).children].map(el => el.outerHTML),
+        [`<p>${'.'.repeat(20000)}</p>`]);
     });
 
     it('creation error', function () {
       this.timeout(5000);
       // 実測500ms程度
       assert.deepStrictEqual(
-        [...parse('.'.repeat(50001)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse('.'.repeat(20001)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
           '<h1 id="error:rnd" class="error">Error: Too many creations</h1>',
           `<pre class="error" translate="no">${'.'.repeat(1000).slice(0, 997)}...</pre>`,

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

@@ -119,7 +119,7 @@ const dataline: CellParser.DatalineParser = creation(1, false, line(
       convert(source => `: ${source}`, data),
     ]))));
 
-function attributes(source: string) {
+function attributes(source: string): Record<string, string | undefined> {
   let [, rowspan = undefined, colspan = undefined, highlight = undefined, extension = undefined] =
     source.match(/^[#:](?:(\d+)?:(\d+)?)?(?:(!+)([+]?))?$/) ?? [];
   assert(rowspan?.[0] !== '0');

package/src/parser/block.ts

@@ -36,8 +36,8 @@ export import MediaBlockParser = BlockParser.MediaBlockParser;
 export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
-export const block: BlockParser = creation(1, false, error(
-  reset({ resources: { clock: 50 * 1000, recursion: 20 } },
+export const block: BlockParser = creation(0, false, error(
+  reset({ resources: { clock: 20000, recursion: 20 + 1 } },
   union([
     emptyline,
     pagebreak,

package/src/parser/inline/annotation.ts

@@ -1,15 +1,15 @@
 import { AnnotationParser } from '../inline';
-import { union, some, syntax, constraint, surround, lazy } from '../../combinator';
+import { union, some, syntax, creation, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { Syntax, State } from '../context';
 import { trimBlankStart, trimNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const annotation: AnnotationParser = lazy(() => surround(
+export const annotation: AnnotationParser = lazy(() => creation(surround(
   '((',
   constraint(State.annotation, false,
-  syntax(Syntax.none, 6, 1, State.annotation | State.media,
+  syntax(Syntax.none, 6, State.annotation | State.media,
   trimBlankStart(some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2], ['))', 6]])))),
   '))',
   false,
-  ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])], rest]));
+  ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])], rest])));

package/src/parser/inline/autolink/account.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { union, constraint, tails, rewrite, open, convert, fmap, lazy } from '../../../combinator';
+import { union, tails, constraint, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
 import { State } from '../../context';

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

@@ -28,5 +28,5 @@ const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creation(prec
   surround('(', some(union([bracket, unescsource]), ')'), ')', true),
   surround('[', some(union([bracket, unescsource]), ']'), ']', true),
   surround('{', some(union([bracket, unescsource]), '}'), '}', true),
-  surround('"', precedence(8, some(unescsource, '"')), '"', true),
+  surround('"', precedence(3, some(unescsource, '"')), '"', true),
 ]))));

package/src/parser/inline/autolink.ts

@@ -12,9 +12,9 @@ import { Syntax, State } from '../context';
 import { stringify } from '../util';
 
 export const autolink: AutolinkParser = lazy(() =>
-  validate(/^(?:[@#>0-9a-z\r\n]|\S[#>])/iu,
+  validate(/^(?:[@#>0-9a-z]|\S[#>]|[\r\n]!?https?:\/\/)/iu,
   constraint(State.autolink, false,
-  syntax(Syntax.autolink, 1, 1, ~State.shortcut,
+  syntax(Syntax.autolink, 1, ~State.shortcut,
   union([
     some(union([lineurl])),
     fmap(some(union([

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

@@ -48,6 +48,9 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('（Ａ）')), [['（', 'Ａ', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（Ａ，Ｂ）')), [['（', 'Ａ，Ｂ', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（Ａ、Ｂ）')), [['（', 'Ａ、Ｂ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('(<bdi>a\\\nb</bdi>)')), [['<span class="paren">(<bdi>a<br>b</bdi>)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('([% a\\\nb %])')), [['<span class="paren">(<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('({{\\\n}})')), [['<span class="paren">(<span class="template">{{\\\n}}</span>)</span>'], '']);
     });
 
     it('[', () => {
@@ -77,8 +80,6 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('"(")"')), [['"', '(', '"'], ')"']);
       assert.deepStrictEqual(inspect(parser('"(("')), [['"', '(', '(', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"')), [['"', '<span class="paren">(")</span>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(\\\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);
     });
 
   });

package/src/parser/inline/bracket.ts

@@ -1,5 +1,5 @@
 import { BracketParser } from '../inline';
-import { union, some, syntax, surround, lazy } from '../../combinator';
+import { union, some, syntax, creation, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
@@ -9,22 +9,21 @@ import { html, defrag } from 'typed-dom/dom';
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
 export const bracket: BracketParser = lazy(() => union([
-  surround(str('('), syntax(Syntax.none, 2, 1, State.none, str(index)), str(')')),
-  surround(str('('), syntax(Syntax.bracket, 2, 1, State.none, some(inline, ')', [[')', 2]])), str(')'), true,
+  surround(str('('), creation(syntax(Syntax.none, 2, State.none, str(index))), str(')')),
+  surround(str('('), creation(syntax(Syntax.bracket, 2, State.none, some(inline, ')', [[/^\\?\n/, 3], [')', 2]]))), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('（'), syntax(Syntax.none, 2, 1, State.none, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
-  surround(str('（'), syntax(Syntax.bracket, 2, 1, State.none, some(inline, '）', [['）', 2]])), str('）'), true,
+  surround(str('（'), creation(syntax(Syntax.none, 2, State.none, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))))), str('）')),
+  surround(str('（'), creation(syntax(Syntax.bracket, 2, State.none, some(inline, '）', [[/^\\?\n/, 3], ['）', 2]]))), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('['), syntax(Syntax.bracket, 2, 1, State.none, some(inline, ']', [[']', 2]])), str(']'), true,
+  surround(str('['), creation(syntax(Syntax.bracket, 2, State.none, some(inline, ']', [[/^\\?\n/, 3], [']', 2]]))), str(']'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('{'), syntax(Syntax.bracket, 2, 1, State.none, some(inline, '}', [['}', 2]])), str('}'), true,
+  surround(str('{'), creation(syntax(Syntax.bracket, 2, State.none, some(inline, '}', [[/^\\?\n/, 3], ['}', 2]]))), str('}'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  // Control media blinking in editing rather than control confusion of pairs of quote marks.
-  surround(str('"'), syntax(Syntax.none, 3, 1, State.none, some(inline, '"', [['"', 3]])), str('"'), true,
+  surround(str('"'), creation(syntax(Syntax.none, 3, State.none, some(inline, '"', [[/^\\?\n/, 4], ['"', 3]]))), str('"'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
 ]));

package/src/parser/inline/deletion.ts

@@ -1,5 +1,5 @@
 import { DeletionParser } from '../inline';
-import { union, some, syntax, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, creation, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
@@ -7,13 +7,13 @@ import { blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const deletion: DeletionParser = lazy(() => surround(
+export const deletion: DeletionParser = lazy(() => creation(surround(
   str('~~', '~'),
-  syntax(Syntax.none, 1, 1, State.none,
+  syntax(Syntax.none, 1, State.none,
   some(union([
     some(inline, blankWith('\n', '~~')),
     open('\n', some(inline, '~'), true),
   ]))),
   str('~~'), false,
   ([, bs], rest) => [[html('del', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/emphasis.ts

@@ -1,5 +1,5 @@
 import { EmphasisParser } from '../inline';
-import { union, some, syntax, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, creation, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { strong } from './strong';
@@ -9,9 +9,9 @@ import { startTight, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const emphasis: EmphasisParser = lazy(() => surround(
+export const emphasis: EmphasisParser = lazy(() => creation(surround(
   str('*', '*'),
-  syntax(Syntax.none, 1, 1, State.none,
+  syntax(Syntax.none, 1, State.none,
   startTight(some(union([
     strong,
     some(inline, blankWith('*'), [[/^\\?\n/, 9]]),
@@ -23,4 +23,4 @@ export const emphasis: EmphasisParser = lazy(() => surround(
   ])))),
   str('*'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/emstrong.ts

@@ -1,6 +1,6 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Result, IntermediateParser } from '../../combinator/data/parser';
-import { union, syntax, some, surround, open, lazy, bind } from '../../combinator';
+import { union, syntax, creation, some, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
@@ -27,9 +27,9 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => surround(
+export const emstrong: EmStrongParser = lazy(() => creation(surround(
   str('***'),
-  syntax(Syntax.none, 1, 1, State.none,
+  syntax(Syntax.none, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('*'), [[/^\\?\n/, 9]]),
     open(some(inline, '*', [[/^\\?\n/, 9]]), inline),
@@ -59,4 +59,4 @@ export const emstrong: EmStrongParser = lazy(() => surround(
     }
     assert(false);
   },
-  ([as, bs], rest) => [unshift(as, bs), rest]));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

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

@@ -20,6 +20,12 @@ describe('Unit: parser/inline/extension/index', () => {
       assert.deepStrictEqual(inspect(parser('[#\\]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a')), undefined);
       assert.deepStrictEqual(inspect(parser('[#*a\nb*]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#(a\nb)]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#"a\nb"]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#<bdi>a\nb</bdi>]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#[% a\nb %]]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#{{ a\nb }}]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[#({{ a\nb }})]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a\n|b]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a|\n]')), undefined);
       assert.deepStrictEqual(inspect(parser('[#a|\\\n]')), undefined);

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

@@ -1,23 +1,23 @@
 import { ExtensionParser } from '../../inline';
-import { union, some, syntax, creation, precedence, constraint, validate, surround, open, lazy, fmap } from '../../../combinator';
+import { union, inits, some, syntax, creation, precedence, constraint, validate, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
-import { txt, str, stropt } from '../../source';
+import { txt, str } from '../../source';
 import { Syntax, State } from '../../context';
 import { startTight, trimNodeEnd } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surround(
+export const index: IndexParser = lazy(() => validate('[#', creation(fmap(indexee(surround(
   '[#',
   constraint(State.index, false,
-  syntax(Syntax.index, 2, 1, State.linkers | State.media,
+  syntax(Syntax.index, 2, State.linkers | State.media,
   startTight(
-  open(stropt('|'), some(union([
-    signature,
+  some(inits([
     inline,
-  ]), ']', [[/^\\?\n/, 9], [']', 2]]), true)))),
+    signature,
+  ]), ']', [[/^\\?\n/, 9], [']', 2]])))),
   ']',
   false,
   ([, ns], rest) => [[html('a', trimNodeEnd(defrag(ns)))], rest])),
@@ -28,18 +28,18 @@ export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surroun
         class: 'index',
         href: el.id ? `#${el.id}` : undefined,
       }),
-  ])));
+  ]))));
 
-export const signature: IndexParser.SignatureParser = lazy(() => creation(fmap(open(
+export const signature: IndexParser.SignatureParser = lazy(() => validate('|', creation(fmap(open(
   '|',
   startTight(some(union([bracket, txt]), ']'))),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity(undefined, ns.join(''))!.slice(7) }),
-  ])));
+  ]))));
 
 const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(union([
   surround(str('('), some(union([bracket, txt]), ')'), str(')'), true),
   surround(str('['), some(union([bracket, txt]), ']'), str(']'), true),
   surround(str('{'), some(union([bracket, txt]), '}'), str('}'), true),
-  surround(str('"'), precedence(8, some(txt, '"')), str('"'), true),
+  surround(str('"'), precedence(3, some(txt, '"')), str('"'), true),
 ])));

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

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../inline';
-import { union, some, syntax, validate, surround, lazy } from '../../../combinator';
+import { union, some, syntax, creation, validate, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { Syntax, State } from '../../context';
@@ -11,9 +11,9 @@ import { html, defrag } from 'typed-dom/dom';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', creation(surround(
   str(/^\[[:^|]/),
-  syntax(Syntax.placeholder, 2, 1, State.none,
+  syntax(Syntax.placeholder, 2, State.none,
   startTight(some(union([inline]), ']', [[']', 2]]))),
   str(']'), false,
   ([, bs], rest) => [[
@@ -24,4 +24,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validat
       'data-invalid-message': `Invalid start symbol or linebreak`,
     }, defrag(bs)),
   ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

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

@@ -75,7 +75,7 @@ describe('Unit: parser/inline/html', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('<bdi>[% </bdi>')), [['<bdi>[% </bdi>'], '']);
+      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>'], '']);

package/src/parser/inline/html.ts

@@ -1,5 +1,5 @@
 import { HTMLParser } from '../inline';
-import { union, subsequence, some, syntax, validate, focus, surround, open, match, lazy } from '../../combinator';
+import { union, subsequence, some, syntax, creation, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
@@ -18,7 +18,7 @@ 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]|>)/i, syntax(Syntax.none, 5, 1, State.none, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(syntax(Syntax.none, 4, State.none, union([
   focus(
     /^<wbr[^\S\n]*>/i,
     () => [[h('wbr')], '']),
@@ -35,7 +35,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 5]]), true)),
+          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 4]]), true)),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
@@ -50,7 +50,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(inline, `</${tag}>`, [[`</${tag}>`, 5]]),
+          some(inline, `</${tag}>`, [[`</${tag}>`, 4]]),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
@@ -59,7 +59,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
           [[elem(tag, as, bs, [])], rest]),
     ([, tag]) => tag,
     new Clock(10000))),
-])))));
+]))))));
 
 export const attribute: HTMLParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="[^"\n]*")?(?=[^\S\n]|>)/i),