securemark 0.289.2 → 0.289.4

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

@@ -1,9 +1,9 @@
 import { ObjectCreate, min } from 'spica/alias';
-import { Parser, Result, Ctx, Tree, Context } from '../../data/parser';
+import { Parser, Result, Ctx, Node, Context } from '../../data/parser';
 import { clone } from 'spica/assign';
 
 export function reset<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
-export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
+export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -13,7 +13,7 @@ export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
 }
 
 export function context<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
-export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
+export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -22,8 +22,8 @@ export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
     apply(parser, source, context, changes, values);
 }
 
-function apply<P extends Parser<unknown>>(parser: P, source: string, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Tree<P>>;
-function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<T> {
+function apply<P extends Parser<unknown>>(parser: P, source: string, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Node<P>>;
+function apply<N>(parser: Parser<N>, source: string, context: Ctx, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<N> {
   if (reset) {
     context.backtracks = {};
   }
@@ -97,7 +97,7 @@ export function recursion(recursion: number, parser: Parser<unknown>): Parser<un
 }
 
 export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
-export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
+export function precedence<N>(precedence: number, parser: Parser<N>): Parser<N> {
   assert(precedence >= 0);
   return input => {
     const { context } = input;
@@ -115,7 +115,7 @@ export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T>
 
 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> {
+export function state<N>(state: number, positive: boolean | Parser<N>, parser?: Parser<N>): Parser<N> {
   if (typeof positive === 'function') {
     parser = positive;
     positive = true;
@@ -136,7 +136,7 @@ export function state<T>(state: number, positive: boolean | Parser<T>, parser?:
 
 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> {
+export function constraint<N>(state: number, positive: boolean | Parser<N>, parser?: Parser<N>): Parser<N> {
   if (typeof positive === 'function') {
     parser = positive;
     positive = true;

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

@@ -1,13 +1,13 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function inits<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[], rest: string) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return ({ source, context }) => {
     let rest = source;
-    let nodes: T[] | undefined;
+    let nodes: N[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') break;
       if (context.delimiters?.match(rest, context)) break;

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

@@ -1,13 +1,13 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function sequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[], rest: string) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return ({ source, context }) => {
     let rest = source;
-    let nodes: T[] | undefined;
+    let nodes: N[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') return;
       if (context.delimiters?.match(rest, context)) return;

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

@@ -6,13 +6,13 @@ type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number,
 
 export function some<P extends Parser<unknown>>(parser: P, limit?: number): P;
 export function some<P extends Parser<unknown>>(parser: P, end?: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
-export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delimiters: readonly DelimiterOption[] = [], limit = -1): Parser<T> {
+export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delimiters: readonly DelimiterOption[] = [], limit = -1): Parser<N> {
   if (typeof end === 'number') return some(parser, undefined, delimiters, end);
   assert(parser);
   assert([end].concat(delimiters.map(o => o[0])).every(d => d instanceof RegExp ? !d.flags.match(/[gmy]/) && d.source.startsWith('^') : true));
   const match = Delimiters.matcher(end);
   const delims = delimiters.map(([delimiter, precedence, linebreakable = true]) => ({
-    signature: Delimiters.signature(delimiter),
+    signature: Delimiters.signature(delimiter, linebreakable),
     matcher: Delimiters.matcher(delimiter),
     precedence,
     linebreakable,
@@ -21,7 +21,7 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
     if (source === '') return;
     assert(context.backtracks ??= {});
     let rest = source;
-    let nodes: T[] | undefined;
+    let nodes: N[] | undefined;
     if (delims.length > 0) {
       context.delimiters ??= new Delimiters();
       context.delimiters.push(delims);

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

@@ -1,9 +1,9 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
-export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function subsequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[], rest: string) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>

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

@@ -1,8 +1,8 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
-export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function tails<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[], rest: string) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[], rest: string) => boolean): Parser<N, Ctx, D> {
   return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

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

@@ -1,7 +1,7 @@
-import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 
-export function union<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function union<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function union<P extends Parser<unknown>>(parsers: SubParsers<P>): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0:

package/src/combinator/data/parser.ts

@@ -1,14 +1,14 @@
 import { Delimiters } from './parser/context/delimiter';
 
-export type Parser<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
-  = (input: Input<C>) => Result<T, C, D>;
+export type Parser<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
+  = (input: Input<C>) => Result<N, C, D>;
 export interface Input<C extends Ctx = Ctx> {
   readonly source: string;
   readonly context: C;
 }
-export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
-  = readonly [T[], string, C, D]
-  | readonly [T[], string]
+export type Result<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
+  = readonly [N[], string, C, D]
+  | readonly [N[], string]
   | undefined;
 export interface Ctx {
   readonly resources?: {
@@ -19,24 +19,25 @@ export interface Ctx {
   precedence?: number;
   delimiters?: Delimiters;
   state?: number;
+  depth?: number;
   backtracks?: Record<number, number>;
   backtrack?: number;
   linebreak?: number;
   recent?: string[];
 }
-export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;
+export type Node<P extends Parser<unknown>> = P extends Parser<infer N> ? N : never;
 export type SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, Ctx, infer D> ? D : never;
 export type Context<P extends Parser<unknown>> = P extends Parser<unknown, infer C> ? C : never;
-export type SubTree<P extends Parser<unknown>> = ExtractSubTree<SubParsers<P>>;
-export type IntermediateParser<P extends Parser<unknown>> = Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-type ExtractSubTree<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer T ? T extends Parser<infer U> ? U : never : never;
+export type SubNode<P extends Parser<unknown>> = ExtractSubNode<SubParsers<P>>;
+export type IntermediateParser<P extends Parser<unknown>> = Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+type ExtractSubNode<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer N ? N extends Parser<infer U> ? U : never : never;
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
 export { eval_ as eval };
-function eval_<T>(result: NonNullable<Result<T>>, default_?: T[]): T[];
-function eval_<T>(result: Result<T>, default_: T[]): T[];
-function eval_<T>(result: Result<T>, default_?: undefined): T[] | undefined;
-function eval_<T>(result: Result<T>, default_?: T[]): T[] | undefined {
+function eval_<N>(result: NonNullable<Result<N>>, default_?: N[]): N[];
+function eval_<N>(result: Result<N>, default_: N[]): N[];
+function eval_<N>(result: Result<N>, default_?: undefined): N[] | undefined;
+function eval_<N>(result: Result<N>, default_?: N[]): N[] | undefined {
   return result
     ? result[0]
     : default_;

package/src/combinator.ts

@@ -11,6 +11,7 @@ export * from './combinator/control/constraint/contract';
 export * from './combinator/control/manipulation/fence';
 export * from './combinator/control/manipulation/indent';
 export * from './combinator/control/manipulation/scope';
+export * from './combinator/control/manipulation/clear';
 export * from './combinator/control/manipulation/surround';
 export * from './combinator/control/manipulation/match';
 export * from './combinator/control/manipulation/convert';

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

@@ -350,7 +350,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack', function () {
       this.timeout(5000);
-      const str = `${'.'.repeat(7 + 0)}((${'['.repeat(13)}{{http://[[[${'.'.repeat(8328)}`;
+      const str = `${'.'.repeat(5 + 0)}{{(([[[http://${'['.repeat(13)}${'.'.repeat(8323)}`;
       assert.deepStrictEqual(
         [...parse(str).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [`<p>${str}</p>`]);
@@ -358,7 +358,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack error', function () {
       this.timeout(5000);
-      const str = `${'.'.repeat(7 + 1)}((${'['.repeat(13)}{{http://[[[${'.'.repeat(8328)}`;
+      const str = `${'.'.repeat(5 + 1)}{{(([[[http://${'['.repeat(13)}${'.'.repeat(8323)}`;
       assert.deepStrictEqual(
         [...parse(str).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [

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

@@ -43,7 +43,7 @@ export const segment: FigureParser.SegmentParser = block(match(
       ]),
     ]),
     closer),
-  ([, fence]) => fence.length, {}), false));
+  ([, fence]) => fence.length, {})));
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),

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

@@ -1,7 +1,7 @@
 import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
-import { Tree, eval } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, block, line, validate, fence, rewrite, surround, open, clear, convert, dup, lazy, fmap } from '../../../combinator';
+import { Node, eval } from '../../../combinator/data/parser';
+import { union, subsequence, inits, some, block, line, validate, fence, rewrite, clear, surround, open, convert, dup, lazy, fmap } from '../../../combinator';
 import { inline, medialink, media, shortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { lineable, invalid } from '../../util';
@@ -147,7 +147,7 @@ function attributes(source: string): Record<string, string | undefined> {
   };
 }
 
-function format(rows: Tree<RowParser>[]): HTMLTableSectionElement[] {
+function format(rows: Node<RowParser>[]): HTMLTableSectionElement[] {
   const thead = html('thead');
   const tbody = html('tbody');
   const tfoot = html('tfoot');

package/src/parser/block/olist.ts

@@ -24,10 +24,10 @@ export const olist: OListParser = lazy(() => block(validate(
 export const olist_: OListParser = lazy(() => block(union([
   match(
     openers['.'],
-    memoize(ms => list(type(ms[1]), '.'), ms => idx(ms[1]), []), false),
+    memoize(ms => list(type(ms[1]), '.'), ms => idx(ms[1]), [])),
   match(
     openers['('],
-    memoize(ms => list(type(ms[1]), '('), ms => idx(ms[1]), []), false),
+    memoize(ms => list(type(ms[1]), '('), ms => idx(ms[1]), [])),
 ])));
 
 const list = (type: string, form: string): OListParser.ListParser => fmap(
@@ -47,10 +47,10 @@ const list = (type: string, form: string): OListParser.ListParser => fmap(
 const heads = {
   '.': focus(
     openers['.'],
-    ({ source }) => [[source.trimEnd().split('.', 1)[0] + '.'], ''], false),
+    ({ source }) => [[source.trimEnd().split('.', 1)[0] + '.'], '']),
   '(': focus(
     openers['('],
-    ({ source }) => [[source.trimEnd().replace(/^\($/, '(1)').replace(/^\((\w+)$/, '($1)')], ''], false),
+    ({ source }) => [[source.trimEnd().replace(/^\($/, '(1)').replace(/^\((\w+)$/, '($1)')], '']),
 } as const;
 
 function idx(value: string): number {

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

@@ -15,9 +15,9 @@ export const cite: ReplyParser.CiteParser = line(fmap(validate(
       anchor,
       // Subject page representation.
       // リンクの実装は後で検討
-      focus(/^>>#\S*(?=\s*$)/, ({ source }) => [[html('a', { class: 'anchor' }, source)], ''], false),
-      focus(/^>>https?:\/\/\S+(?=\s*$)/, ({ source }) => [[html('a', { class: 'anchor', href: source.slice(2).trimEnd(), target: '_blank' }, source)], ''], false),
-      focus(/^>>.+(?=\s*$)/, ({ source }) => [[source], ''], false),
+      focus(/^>>#\S*(?=\s*$)/, ({ source }) => [[html('a', { class: 'anchor' }, source)], '']),
+      focus(/^>>https?:\/\/\S+(?=\s*$)/, ({ source }) => [[html('a', { class: 'anchor', href: source.slice(2).trimEnd(), target: '_blank' }, source)], '']),
+      focus(/^>>.+(?=\s*$)/, ({ source }) => [[source], '']),
     ]),
   )),
   ([quotes, node]: [string, HTMLElement | string]) => [

package/src/parser/block/ulist.ts

@@ -33,7 +33,7 @@ export const checkbox = focus(
   /^\[[xX ]\](?=$|\s)/,
   ({ source }) => [[
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
-  ], ''], false);
+  ], '']);
 
 export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | string)[] {
   return ns.length === 1

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

@@ -7,7 +7,11 @@ import { str } from '../../source';
 import { define } from 'typed-dom/dom';
 
 export const hashnum: AutolinkParser.HashnumParser = lazy(() => rewrite(
-  open('#', str(new RegExp(/^[0-9]{1,9}(?![^\p{C}\p{S}\p{P}\s]|emoji)/u.source.replace(/emoji/, emoji), 'u'))),
+  open(
+    '#',
+    str(new RegExp([
+      /^[0-9]{1,9}(?![^\p{C}\p{S}\p{P}\s]|emoji)/u.source,
+    ].join('').replace(/emoji/, emoji), 'u'))),
   union([
     constraint(State.autolink, false, state(State.autolink, fmap(convert(
       source => `[${source}]{ ${source.slice(1)} }`,

package/src/parser/inline/code.ts

@@ -5,7 +5,8 @@ import { html } from 'typed-dom/dom';
 export const code: CodeParser = match(
   /^(`+)(?!`)([^\n]*?[^`\n])\1(?!`)/,
   ([whole, , body]) => ({ source }) =>
-    [[html('code', { 'data-src': whole }, format(body))], source.slice(whole.length)]);
+    [[html('code', { 'data-src': whole }, format(body))], source.slice(whole.length)],
+  true);
 
 function format(text: string): string {
   assert(text.length > 0);

package/src/parser/inline/emstrong.ts

@@ -28,7 +28,8 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-// 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず早く閉じるよう解析しなければならない。
+// 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず
+// 可能な限り早く閉じるよう解析しなければならない。
 // このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
 export const emstrong: EmStrongParser = lazy(() => validate('***',
   precedence(0, repeat('***', surround(

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

@@ -3,6 +3,12 @@ import { union, focus, surround } from '../../../combinator';
 import { signature } from './index';
 import { html } from 'typed-dom/dom';
 
+// インデクスの重複解消は不要な重複を削除するのが最もよい。
+// 複合生成インデクスは参照と同期させることが困難であり
+// 複合生成インデクスを手動で同期させるより最初から重複のない
+// テキストまたはインデクスを付けて同期が必要な機会を減らすのが
+// 継続的編集において最も簡便となる。
+
 export const indexer: ExtensionParser.IndexerParser = surround(
   /^\s+\[(?=\|\S)/,
   union([

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

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { State, Backtrack } from '../../context';
-import { union, constraint, surround, clear, fmap } from '../../../combinator';
+import { union, constraint, clear, surround, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 

package/src/parser/inline/html.ts

@@ -53,8 +53,8 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
       /^<([a-z]+)(?=[^\S\n]|>)/i,
       memoize(
       ([, tag]) =>
-        surround<HTMLParser.TagParser, string>(surround(
-          str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
+        surround<HTMLParser.TagParser, string>(
+          surround(str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
           precedence(3, recursion(Recursion.inline,
           subsequence([
             focus(/^[^\S\n]*\n/, some(inline)),

package/src/parser/inline.test.ts

@@ -70,6 +70,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('***a*b*c*')), [['**', '<em>a</em>', 'b', '<em>c</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*c**')), [['**', '<em>a</em>', 'b', '<em>c</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*c***')), [['<strong><em>a</em>b<em>c</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b**c***')), [['<em><strong>a</strong>b<strong>c</strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*(*a*)*')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
       assert.deepStrictEqual(inspect(parser('**(**a**)**')), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('*[*]')), [['*', '[', '*', ']'], '']);

package/src/parser/inline.ts

@@ -1,5 +1,5 @@
 import { MarkdownParser } from '../../markdown';
-import { union, lazy } from '../combinator';
+import { union, verify, lazy } from '../combinator';
 import { annotation } from './inline/annotation';
 import { reference } from './inline/reference';
 import { template } from './inline/template';
@@ -47,10 +47,12 @@ export import ShortMediaParser = InlineParser.ShortMediaParser;
 export import BracketParser = InlineParser.BracketParser;
 export import AutolinkParser = InlineParser.AutolinkParser;
 
-export const inline: InlineParser = lazy(() => union([
+export const inline: InlineParser = lazy(() => verify(union([
   input => {
-    const { source } = input;
+    const { source, context } = input;
     if (source === '') return;
+    context.depth ??= 0;
+    ++context.depth;
     switch (source.slice(0, 2)) {
       case '((':
         return annotation(input);
@@ -104,7 +106,20 @@ export const inline: InlineParser = lazy(() => union([
   bracket,
   autolink,
   text
-])) as any;
+]), (_, rest, context) => {
+  --context.depth!;
+  assert([rest]);
+  // ヒープを効率的に削除可能な場合は削除する。
+  // ヒープサイズは括弧類など特定の構文が完成しなかった場合にしか増加しないため
+  // ブロックごとに平均数ノード以下となることから削除せずとも平均的にはあまり影響はない。
+  //if (context.depth === 0) {
+  //  const { backtracks } = context;
+  //  while (backtracks.peek()?.key! > rest.length) {
+  //    backtracks.extract();
+  //  }
+  //}
+  return true;
+})) as any;
 
 export { indexee } from './inline/extension/indexee';
 export { indexer } from './inline/extension/indexer';

package/src/parser/util.ts

@@ -1,19 +1,19 @@
 import { min } from 'spica/alias';
 import { Command } from './context';
-import { Parser, Result, Ctx, Tree, Context, eval, exec } from '../combinator/data/parser';
+import { Parser, Result, Ctx, Node, Context, eval, exec } from '../combinator/data/parser';
 import { convert } from '../combinator';
 import { define } from 'typed-dom/dom';
 
 export function lineable<P extends Parser<HTMLElement | string>>(parser: P, fillTrailingLinebreak?: boolean): P;
-export function lineable<T extends HTMLElement | string>(parser: Parser<T>, fillTrailingLinebreak = false): Parser<T> {
+export function lineable<N extends HTMLElement | string>(parser: Parser<N>, fillTrailingLinebreak = false): Parser<N> {
   return convert(
     source => `\r${source}${fillTrailingLinebreak && source.at(-1) !== '\n' ? '\n' : ''}`,
     parser,
     !fillTrailingLinebreak);
 }
 
-export function repeat<P extends Parser<HTMLElement | string>>(symbol: string, parser: P, cons: (nodes: Tree<P>[], context: Context<P>) => Tree<P>[], termination?: (acc: Tree<P>[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | Tree<P>>): P;
-export function repeat<T extends HTMLElement | string>(symbol: string, parser: Parser<T>, cons: (nodes: T[], context: Ctx) => T[], termination: (acc: T[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | T> = (acc, rest, prefix, postfix) => {
+export function repeat<P extends Parser<HTMLElement | string>>(symbol: string, parser: P, cons: (nodes: Node<P>[], context: Context<P>) => Node<P>[], termination?: (acc: Node<P>[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
+export function repeat<N extends HTMLElement | string>(symbol: string, parser: Parser<N>, cons: (nodes: N[], context: Ctx) => N[], termination: (acc: N[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | N> = (acc, rest, prefix, postfix) => {
   const nodes = [];
   if (prefix > 0) {
     nodes.push(symbol[0].repeat(prefix));
@@ -26,11 +26,11 @@ export function repeat<T extends HTMLElement | string>(symbol: string, parser: P
     rest = rest.slice(postfix);
   }
   return [nodes, rest];
-}): Parser<string | T> {
+}): Parser<string | N> {
   return input => {
     const { source, context } = input;
     assert(source.startsWith(symbol));
-    let acc: T[][] = [];
+    let acc: N[][] = [];
     let i = symbol.length;
     while (source[i] === source[0]) ++i;
     let rest = source.slice(i);
@@ -87,12 +87,12 @@ export function invalid(
   };
 }
 
-export function markInvalid<T extends Element>(
-  el: T,
+export function markInvalid<N extends HTMLElement>(
+  el: N,
   syntax: string,
   type: string,
   message: string,
-): T {
+): N {
   assert(!message.endsWith('.'));
   return define(el, {
     class: void el.classList.add('invalid'),
@@ -102,7 +102,7 @@ export function markInvalid<T extends Element>(
   });
 }
 
-export function unmarkInvalid<T extends Element>(el: T): T {
+export function unmarkInvalid<N extends HTMLElement>(el: N): N {
   return define(el, {
     class: void el.classList.remove('invalid'),
     'data-invalid-syntax': null,

package/src/parser/visibility.ts

@@ -18,7 +18,7 @@ export namespace blank {
 }
 
 export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+export function visualize<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
   return union([
     convert(
       source => source.replace(blank.line, line => line.replace(/[\\&<]/g, `${Command.Escape}$&`)),
@@ -60,7 +60,7 @@ export function blankWith(starts: '' | '\n', delimiter?: string | RegExp): RegEx
 }
 
 //export function looseStart<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
-//export function looseStart<T extends HTMLElement | string>(parser: Parser<T>, except?: string): Parser<T> {
+//export function looseStart<N extends HTMLElement | string>(parser: Parser<N>, except?: string): Parser<N> {
 //  return input =>
 //    isLooseStart(input, except)
 //      ? parser(input)
@@ -71,7 +71,7 @@ export function blankWith(starts: '' | '\n', delimiter?: string | RegExp): RegEx
 //}, ({ source }, except = '') => `${source}${Command.Separator}${except}`);
 
 export function tightStart<P extends Parser<unknown>>(parser: P, except?: string): P;
-export function tightStart<T>(parser: Parser<T>, except?: string): Parser<T> {
+export function tightStart<N>(parser: Parser<N>, except?: string): Parser<N> {
   return input =>
     isTightStart(input, except)
       ? parser(input)
@@ -155,31 +155,31 @@ function isVisible(node: HTMLElement | string, strpos?: number): boolean {
 
 // デフラグ前の非効率な後方トリムを避けるため必要のない限りtrimBlankStart+trimNodeEndで処理する。
 export function trimBlank<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function trimBlank<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+export function trimBlank<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
   return trimBlankStart(trimBlankEnd(parser));
 }
 export function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
-export function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
+export function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
   return convert(
     source => source.replace(blank.start, ''),
     parser,
     true);
 }
 export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+export function trimBlankEnd<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
   return fmap(
     parser,
     trimBlankNodeEnd);
 }
-//export function trimBlankNode<T extends HTMLElement | string>(nodes: T[]): T[] {
+//export function trimBlankNode<N extends HTMLElement | string>(nodes: N[]): N[] {
 //  return trimBlankNodeStart(trimBlankNodeEnd(nodes));
 //}
-//function trimBlankNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
+//function trimBlankNodeStart<N extends HTMLElement | string>(nodes: N[]): N[] {
 //  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
 //    if (typeof node === 'string') {
 //      const pos = node.trimStart().length;
 //      if (pos > 0) {
-//        nodes[0] = node.slice(-pos) as T;
+//        nodes[0] = node.slice(-pos) as N;
 //        break;
 //      }
 //    }
@@ -190,7 +190,7 @@ export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>):
 //  }
 //  return nodes;
 //}
-export function trimBlankNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
+export function trimBlankNodeEnd<N extends HTMLElement | string>(nodes: N[]): N[] {
   const skip = nodes.length > 0 &&
     typeof nodes.at(-1) === 'object' &&
     nodes.at(-1)!['className'] === 'indexer'
@@ -200,7 +200,7 @@ export function trimBlankNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[
     if (typeof node === 'string') {
       const len = node.trimEnd().length;
       if (len > 0) {
-        nodes[nodes.length - 1] = node.slice(0, len) as T;
+        nodes[nodes.length - 1] = node.slice(0, len) as N;
         break;
       }
     }

package/src/util/quote.ts

@@ -82,7 +82,7 @@ function fit(range: Range): void {
   }
 }
 
-function trim<T extends Node>(node: T): T {
+function trim<N extends Node>(node: N): N {
   for (let child: ChildNode & Node | null; child = node.firstChild;) {
     if (child.textContent) break;
     child.remove();