securemark 0.279.1 → 0.280.1

package/markdown.d.ts

@@ -631,12 +631,6 @@ export namespace MarkdownParser {
       export namespace QuoteParser {
         export interface BlockParser extends
           Block<'reply/quote/block'>,
-          Parser<string | HTMLElement, Context, [
-            TextParser,
-          ]> {
-        }
-        export interface TextParser extends
-          Block<'reply/quote/text'>,
           Parser<string | HTMLElement, Context, [
             InlineParser.MathParser,
             InlineParser.AutolinkParser,
@@ -784,8 +778,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.1",
   "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/combinator/data/parser/some.ts

@@ -22,7 +22,7 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
     let nodes: T[] | undefined;
     if (delims.length > 0) {
       context.delimiters ??= new Delimiters();
-      context.delimiters.push(...delims);
+      context.delimiters.push(delims);
     }
     while (true) {
       if (rest === '') break;

package/src/parser/api/bind.ts

@@ -26,9 +26,12 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
     memo: new Memo({ targets: State.backtrackers }),
   };
+  assert(!context.offset);
+  assert(!context.precedence);
+  assert(!context.delimiters);
+  assert(!context.state);
   if (context.id?.match(/[^0-9a-z/-]/i)) throw new Error('Invalid ID: ID must be alphanumeric');
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
-  assert(!settings.id);
   type Block = readonly [segment: string, blocks: readonly HTMLElement[], url: string];
   const blocks: Block[] = [];
   const adds: [HTMLElement, Node | null][] = [];

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/api/parse.ts

@@ -21,7 +21,6 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
   if (!validate(source, MAX_SEGMENT_SIZE)) throw new Error(`Too large input over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes`);
   const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
   source = !context ? normalize(source) : source;
-  assert(!context?.delimiters);
   context = {
     host: opts.host ?? context?.host ?? new ReadonlyURL(location.pathname, location.origin),
     url: url ? new ReadonlyURL(url as ':') : context?.url,
@@ -32,6 +31,10 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
     },
     memo: new Memo({ targets: State.backtrackers }),
   };
+  assert(!context.offset);
+  assert(!context.precedence);
+  assert(!context.delimiters);
+  assert(!context.state);
   if (context.id?.match(/[^0-9a-z/-]/i)) throw new Error('Invalid ID: ID must be alphanumeric');
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   const node = frag();

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/heading.ts

@@ -18,7 +18,7 @@ export const heading: HeadingParser = block(rewrite(segment,
       visualize(trimBlankStart(some(union([indexer, inline])))), true),
     open(
       str('#'),
-      state(State.autolink,
+      state(State.linkers,
       visualize(trimBlankStart(some(union([indexer, inline]))))), true),
   ]),
   ([h, ...ns]: [string, ...(HTMLElement | string)[]]) => [

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

@@ -1,6 +1,5 @@
 import { ReplyParser } from '../../block';
-import { eval } from '../../../combinator/data/parser';
-import { union, some, creation, block, line, validate, rewrite, lazy, fmap } from '../../../combinator';
+import { union, some, creation, block, line, validate, rewrite, convert, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { autolink } from '../../inline/autolink';
 import { linebreak, unescsource, str, anyline } from '../../source';
@@ -33,47 +32,11 @@ export const quote: ReplyParser.QuoteParser = lazy(() => creation(1, false, bloc
   ]),
   false)));
 
-const qblock: ReplyParser.QuoteParser.BlockParser = ({ source, context }) => {
-  source = source.replace(/\n$/, '');
-  const lines = source.match(/^.*\n?/mg)!;
-  assert(lines);
-  const quotes = source.match(/^>+[^\S\n]/mg)!;
-  assert(quotes);
-  assert(quotes.length > 0);
-  const content = lines.reduce((acc, line, i) => acc + line.slice(quotes[i].length), '');
-  const nodes = eval(text({ source: `\r${content}`, context }), []);
-  nodes.unshift(quotes.shift()!);
-  for (let i = 0; i < nodes.length; ++i) {
-    const child = nodes[i] as string | Text | Element;
-    if (typeof child === 'string') continue;
-    if ('wholeText' in child) {
-      nodes[i] = child.data;
-      continue;
-    }
-    assert(child instanceof HTMLElement);
-    if (child.tagName === 'BR') {
-      assert(quotes.length > 0);
-      nodes.splice(i + 1, 0, quotes.shift()!);
-      ++i;
-      continue;
-    }
-    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;
-    }
-  }
-  nodes.unshift('');
-  assert(nodes.length > 1);
-  assert(nodes.every(n => typeof n === 'string' || n instanceof HTMLElement));
-  assert(quotes.length === 0);
-  return [nodes, ''];
-};
-
-const text: ReplyParser.QuoteParser.TextParser = some(union([
-  math, // quote補助関数が残した数式をパースする。他の構文で数式を残す場合はソーステキストを直接使用する。
-  autolink,
-  linebreak,
-  unescsource,
-]));
+const qblock: ReplyParser.QuoteParser.BlockParser = convert(
+  source => source.replace(/\n$/, '').replace(/(?<=^>+[^\S\n])/mg, '\r'),
+  some(union([
+    math, // quote補助関数が残した数式をパースする。他の構文で数式を残す場合はソーステキストを直接使用する。
+    autolink,
+    linebreak,
+    unescsource,
+  ])));

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);