securemark 0.282.0 → 0.283.1

package/markdown.d.ts

@@ -819,8 +819,8 @@ export namespace MarkdownParser {
       // [AB](a b)
       Inline<'ruby'>,
       Parser<HTMLElement, Context, [
-        SourceParser.StrParser,
-        SourceParser.StrParser,
+        Parser<string[], Context, []>,
+        Parser<string[], Context, []>,
       ]> {
     }
     export namespace RubyParser {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.282.0",
+  "version": "0.283.1",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -28,7 +28,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "spica": "0.0.804"
+    "spica": "0.0.805"
   },
   "devDependencies": {
     "@types/dompurify": "3.0.5",

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

@@ -1,8 +1,5 @@
 import { Parser, Ctx, Context, check } from '../../data/parser';
-import { max } from 'spica/alias';
 
-// 設計上キャッシュが汚染されるが運用で回避可能
-// 変換の前または後のみキャッシュされるなら問題ない
 export function convert<P extends Parser<unknown>>(conv: (source: string, context: Context<P>) => string, parser: P, empty?: boolean): P;
 export function convert<T>(conv: (source: string, context: Ctx) => string, parser: Parser<T>, empty = false): Parser<T> {
   assert(parser);
@@ -10,13 +7,12 @@ export function convert<T>(conv: (source: string, context: Ctx) => string, parse
     if (source === '') return;
     const src = conv(source, context);
     if (src === '') return empty ? [[], ''] : undefined;
-    const offset = max(source.length - src.length, 0);
-    assert(offset >= 0);
-    context.offset ??= 0;
-    context.offset += offset;
+    const sub = source.endsWith(src);
+    const { logger } = context;
+    context.logger = sub ? logger : {};
     const result = parser({ source: src, context });
     assert(check(src, result));
-    context.offset -= offset;
+    context.logger = logger;
     return result;
   };
 }

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

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

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

@@ -34,11 +34,14 @@ export function rewrite<T>(scope: Parser<unknown>, parser: Parser<T>): Parser<T>
   assert(parser);
   return ({ source, context }) => {
     if (source === '') return;
-    const memo = context.memo;
-    context.memo = undefined;
+    const { logger } = context;
+    context.logger = {};
+    //const { resources = { clock: 0 } } = context;
+    //const clock = resources.clock;
     const res1 = scope({ source, context });
     assert(check(source, res1));
-    context.memo = memo;
+    //resources.clock = clock;
+    context.logger = logger;
     if (res1 === undefined || exec(res1).length >= source.length) return;
     const src = source.slice(0, source.length - exec(res1).length);
     assert(src !== '');

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

@@ -3,39 +3,49 @@ import { fmap } from '../monad/fmap';
 import { unshift, push } from 'spica/array';
 
 export function surround<P extends Parser<unknown>, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>, optional?: false,
+  opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
+  optional?: false,
   f?: (rss: [S[], SubTree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], SubTree<P>[], string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  log?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>, optional?: boolean,
+  opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
+  optional?: boolean,
   f?: (rss: [S[], SubTree<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], SubTree<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  log?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>, optional?: false,
+  opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
+  optional?: false,
   f?: (rss: [S[], Tree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], Tree<P>[], string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  log?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
-  opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>, optional?: boolean,
+  opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
+  optional?: boolean,
   f?: (rss: [S[], Tree<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], Tree<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  log?: number,
 ): P;
 export function surround<T>(
-  opener: string | RegExp | Parser<T>, parser: Parser<T>, closer: string | RegExp | Parser<T>, optional: boolean = false,
+  opener: string | RegExp | Parser<T>, parser: Parser<T>, closer: string | RegExp | Parser<T>,
+  optional: boolean = false,
   f?: (rss: [T[], T[], T[]], rest: string, context: Ctx) => Result<T>,
   g?: (rss: [T[], T[], string], rest: string, context: Ctx) => Result<T>,
+  log: number = 0,
 ): Parser<T> {
   switch (typeof opener) {
     case 'string':
     case 'object':
-      return surround(match(opener), parser, closer, optional, f, g);
+      opener = match(opener);
   }
   switch (typeof closer) {
     case 'string':
     case 'object':
-      return surround(opener, parser, match(closer), optional, f, g);
+      closer = match(closer);
   }
   return ({ source, context }) => {
     const lmr_ = source;
@@ -45,6 +55,16 @@ export function surround<T>(
     if (res1 === undefined) return;
     const rl = eval(res1);
     const mr_ = exec(res1);
+    if (log & 1) {
+      const { logger = {}, offset = 0 } = context;
+      for (let i = 0; i < source.length - mr_.length; ++i) {
+        if (source[i] !== source[0]) break;
+        const j = source.length + offset - i;
+        if (!(j in logger)) continue;
+        assert(log >>> 2);
+        if (logger[j] & 1 << (log >>> 2)) return;
+      }
+    }
     const res2 = mr_ !== '' ? parser({ source: mr_, context }) : undefined;
     assert(check(mr_, res2));
     const rm = eval(res2);
@@ -55,6 +75,10 @@ export function surround<T>(
     const rr = eval(res3);
     const rest = exec(res3, r_);
     if (rest.length === lmr_.length) return;
+    if (log & 2 && rr === undefined) {
+      const { logger = {}, offset = 0 } = context;
+      logger[source.length + offset] |= 1 << (log >>> 2);
+    }
     return rr
       ? f
         ? f([rl, rm!, rr], rest, context)

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

@@ -9,11 +9,11 @@ describe('Unit: combinator/data/parser/context', () => {
   }
 
   describe('reset', () => {
-    const parser: Parser<number> = some(creation(
+    const parser: Parser<number> = some(creation(1, 1,
       ({ source, context }) => [[context.resources?.clock ?? NaN], source.slice(1)]));
 
     it('root', () => {
-      const base: Context = { resources: { clock: 3, recursion: 1 } };
+      const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = {};
       assert.deepStrictEqual(reset(base, parser)({ source: '123', context: ctx }), [[3, 2, 1], '']);
       assert(base.resources?.clock === 3);
@@ -24,8 +24,8 @@ describe('Unit: combinator/data/parser/context', () => {
     });
 
     it('node', () => {
-      const base: Context = { resources: { clock: 3, recursion: 1 } };
-      const ctx: Context = { resources: { clock: 1, recursion: 1 } };
+      const base: Context = { resources: { clock: 3, recursions: [1] } };
+      const ctx: Context = { resources: { clock: 1, recursions: [1] } };
       assert.deepStrictEqual(reset(base, parser)({ source: '1', context: ctx }), [[1], '']);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === 0);
@@ -36,12 +36,12 @@ describe('Unit: combinator/data/parser/context', () => {
   });
 
   describe('context', () => {
-    const parser: Parser<boolean, Context> = some(creation(
+    const parser: Parser<boolean, Context> = some(creation(1, 1,
       ({ source, context }) => [[context.status!], source.slice(1)]));
 
     it('', () => {
       const base: Context = { status: true };
-      const ctx: Context = { resources: { clock: 3, recursion: 1 } };
+      const ctx: Context = { resources: { clock: 3, recursions: [1] } };
       assert.deepStrictEqual(context(base, parser)({ source: '123', context: ctx }), [[true, true, true], '']);
       assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);

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

@@ -1,6 +1,6 @@
-import { ObjectCreate } from 'spica/alias';
-import { Parser, Result, Ctx, Tree, Context, eval, exec } from '../../data/parser';
-import { Memo } from './context/memo';
+import { ObjectCreate, min } from 'spica/alias';
+import { Parser, Result, Ctx, Tree, 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> {
@@ -24,7 +24,9 @@ export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
 
 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> {
-  reset && context.memo?.clear();
+  if (reset) {
+    context.logger = {};
+  }
   for (let i = 0; i < changes.length; ++i) {
     const change = changes[i];
     const prop = change[0];
@@ -35,7 +37,7 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: read
         assert(!context.precedence);
         assert(!context.delimiters);
         assert(!context.state);
-        context[prop as string] ??= ObjectCreate(change[1] as object);
+        context[prop as string] ??= clone({}, change[1] as object);
         continue;
     }
     values[i] = context[prop];
@@ -56,51 +58,35 @@ 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, state: number, parser: P): P;
-export function syntax<T>(syntax: number, prec: number, state: number, parser: Parser<T>): Parser<T> {
+export function syntax<P extends Parser<unknown>>(precedence: number, state: number, parser: P): P;
+export function syntax<T>(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;
-    const position = source.length + context.offset!;
     const stateOuter = context.state ?? 0;
-    const stateInner = context.state = stateOuter | state;
-    const cache = syntax & memo.targets && stateInner && memo.get(position, syntax, stateInner);
-    const result: Result<T> = cache
-      ? cache.length === 0
-        ? undefined
-        : [cache[0] as T[], source.slice(cache[1])]
-      : parser({ source, context });
-    if (stateOuter && !cache && syntax & memo.targets) {
-      memo.set(position, syntax, stateInner, eval(result), source.length - exec(result, '').length);
-    }
-    else if (!stateOuter && result && memo.length >= position + memo.margin) {
-      memo.resize(position + memo.margin);
-    }
+    context.state = stateOuter | state;
+    const result: Result<T> = parser({ source, context });
     context.state = stateOuter;
     return result;
   });
 }
 
-export function creation<P extends Parser<unknown>>(parser: P): P;
-export function creation<P extends Parser<unknown>>(cost: number, parser: P): P;
-export function creation<P extends Parser<unknown>>(cost: number, recursion: boolean, parser: P): P;
-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);
+export function creation<P extends Parser<unknown>>(cost: number, recursion: number, parser: P): P;
+export function creation(cost: number, recursion: number, parser: Parser<unknown>): Parser<unknown> {
   assert(cost >= 0);
-  assert(recursion !== undefined);
+  assert(recursion >= 0);
   return ({ source, context }) => {
-    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 < +recursion) throw new Error('Too much recursion');
-    recursion && --resources.recursion;
-    const result = parser!({ source, context });
-    recursion && ++resources.recursion;
-    if (result) {
-      resources.clock -= cost;
-    }
+    const resources = context.resources ?? { clock: cost || 1, recursions: [1] };
+    const { recursions } = resources;
+    assert(recursions.length > 0);
+    const rec = min(recursion, recursions.length);
+    if (rec > 0 && recursions[rec - 1] < 1) throw new Error('Too much recursion');
+    rec > 0 && --recursions[rec - 1];
+    const result = parser({ source, context });
+    rec > 0 && ++recursions[rec - 1];
+    if (result === undefined) return;
+    if (resources.clock < cost) throw new Error('Too many creations');
+    resources.clock -= cost;
     return result;
   };
 }

package/src/combinator/data/parser.ts

@@ -1,5 +1,4 @@
 import { Delimiters } from './parser/context/delimiter';
-import { Memo } from './parser/context/memo';
 
 export type Parser<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   = (input: Input<C>) => Result<T, C, D>;
@@ -14,13 +13,13 @@ export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
 export interface Ctx {
   readonly resources?: {
     clock: number;
-    recursion: number;
+    recursions: number[];
   };
   offset?: number;
   precedence?: number;
   delimiters?: Delimiters;
   state?: number;
-  memo?: Memo;
+  logger?: Record<number, number>;
 }
 export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;
 export type SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, Ctx, infer D> ? D : never;

package/src/parser/api/bind.ts

@@ -1,8 +1,6 @@
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
-import { Memo } from '../../combinator/data/parser/context/memo';
-import { Syntax, Margin } from '../context';
 import { segment, validate, MAX_INPUT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
@@ -24,7 +22,6 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   let context: MarkdownParser.Context = {
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
-    memo: new Memo(Syntax.targets, Margin),
   };
   assert(!context.offset);
   assert(!context.precedence);
@@ -87,9 +84,10 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       // All deletion processes always run after all addition processes have done.
       // Therefore any `base` node will never be unavailable by deletions until all the dependent `el` nodes are added.
       push(adds, es.map(el => [el, base] as const));
+      adds.reverse();
       while (adds.length > 0) {
         assert(rev === revision);
-        const [el, base] = adds.shift()!;
+        const [el, base] = adds.pop()!;
         target.insertBefore(el, base);
         assert(el.parentNode);
         yield { type: 'block', value: el };
@@ -103,17 +101,19 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       push(dels, es.map(el => [el]));
     }
     assert(blocks.length === sourceSegments.length);
+    adds.reverse();
     while (adds.length > 0) {
       assert(rev === revision);
-      const [el, base] = adds.shift()!;
+      const [el, base] = adds.pop()!;
       target.insertBefore(el, base);
       assert(el.parentNode);
       yield { type: 'block', value: el };
       if (rev !== revision) return yield { type: 'cancel' };
     }
+    dels.reverse();
     while (dels.length > 0) {
       assert(rev === revision);
-      const [el] = dels.shift()!;
+      const [el] = dels.pop()!;
       el.parentNode?.removeChild(el);
       assert(!el.parentNode);
       yield { type: 'block', value: el };

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

@@ -286,47 +286,47 @@ describe('Unit: parser/api/parse', () => {
         ['<p>a<br>b</p>']);
     });
 
-    it('backtrack', () => {
+    it('recursion', () => {
+      assert.deepStrictEqual(
+        [...parse(`${'{'.repeat(20)}a`).children].map(el => el.outerHTML),
+        [`<p>${'{'.repeat(20)}a</p>`]);
       assert.deepStrictEqual(
-        [...parse('"[% '.repeat(100) + '\n\na').children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse(`${'{'.repeat(21)}a`).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(100)}\n</pre>`,
-          '<p>a</p>',
+          `<pre class="error" translate="no">${'{'.repeat(21)}a</pre>`,
         ]);
-    });
-
-    it('recursion', () => {
       assert.deepStrictEqual(
-        [...parse('{'.repeat(21)).children].map(el => el.outerHTML),
-        [`<p>${'{'.repeat(21)}</p>`]);
+        [...parse(`${'('.repeat(22)}a`).children].map(el => el.outerHTML),
+        [`<p>${'('.repeat(22)}a</p>`]);
       assert.deepStrictEqual(
-        [...parse('{'.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse(`${'('.repeat(23)}a`).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(22)}</pre>`,
+          `<pre class="error" translate="no">${'('.repeat(23)}a</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse('('.repeat(21)).children].map(el => el.outerHTML),
-        [`<p>${'('.repeat(21)}</p>`]);
+        [...parse(`${'['.repeat(23)}a`).children].map(el => el.outerHTML),
+        [`<p>${'['.repeat(23)}a</p>`]);
       assert.deepStrictEqual(
-        [...parse('('.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse(`${'['.repeat(24)}a`).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(22)}</pre>`,
+          `<pre class="error" translate="no">${'['.repeat(24)}a</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse('['.repeat(21)).children].map(el => el.outerHTML),
-        [`<p>${'['.repeat(21)}</p>`]);
+        [...parse(`${'['.repeat(22)}\na`).children].map(el => el.outerHTML),
+        [`<p>${'['.repeat(22)}<br>a</p>`]);
+    });
+
+    it('recovery', () => {
       assert.deepStrictEqual(
-        [...parse('['.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse(`${'{'.repeat(21)}\n\na`).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(22)}</pre>`,
+          `<h1 id="error:rnd" class="error">Error: Too much recursion</h1>`,
+          `<pre class="error" translate="no">${'{'.repeat(21)}\n</pre>`,
+          '<p>a</p>',
         ]);
-      assert.deepStrictEqual(
-        [...parse('['.repeat(20) + '\na').children].map(el => el.outerHTML),
-        [`<p>${'['.repeat(20)}<br>a</p>`]);
     });
 
     if (!navigator.userAgent.includes('Chrome')) return;
@@ -344,17 +344,24 @@ describe('Unit: parser/api/parse', () => {
         [...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>`,
+          `<pre class="error" translate="no">${'.'.repeat(1000 - 3)}...</pre>`,
         ]);
     });
 
-    it('recovery', function () {
+    it('backtrack', function () {
+      this.timeout(5000);
+      assert.deepStrictEqual(
+        [...parse(`(({{${'['.repeat(19)}${'.'.repeat(3301)}`).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [`<p>(({{${'['.repeat(19)}${'.'.repeat(3301)}</p>`]);
+    });
+
+    it('backtrack error', function () {
       this.timeout(5000);
       assert.deepStrictEqual(
-        [...parse(`!>> ${'['.repeat(20)}${'{a}'.repeat(518)}\n> ${'{a}'.repeat(4)}\n\na`).children].map(el => el.outerHTML),
+        [...parse(`(({{${'['.repeat(19)}${'.'.repeat(3302)}`).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
-          `<blockquote><blockquote><section><p>${'['.repeat(20)}${'<a class="url" href="a">a</a>'.repeat(518)}</p><h2>References</h2><ol class="references"></ol></section></blockquote><section><h1 class="error">Error: Too many creations</h1><pre class="error" translate="no">{a}{a}{a}{a}</pre><h2>References</h2><ol class="references"></ol></section></blockquote>`,
-          '<p>a</p>',
+          '<h1 id="error:rnd" class="error">Error: Too many creations</h1>',
+          `<pre class="error" translate="no">(({{${'['.repeat(19)}${'.'.repeat(1000 - 4 - 19 - 3)}...</pre>`,
         ]);
     });
 

package/src/parser/api/parse.ts

@@ -1,8 +1,6 @@
 import { ParserOptions } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
-import { Memo } from '../../combinator/data/parser/context/memo';
-import { Syntax, Margin } from '../context';
 import { segment, validate, MAX_SEGMENT_SIZE } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
@@ -27,7 +25,6 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
     id: opts.id ?? context?.id,
     caches: context?.caches,
     resources: context?.resources,
-    memo: new Memo(Syntax.targets, Margin),
   };
   assert(!context.offset);
   assert(!context.precedence);

package/src/parser/block/blockquote.ts

@@ -2,6 +2,7 @@ import { BlockquoteParser } from '../block';
 import { union, some, creation, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
+import { Recursion } from '../context';
 import { parse } from '../api/parse';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -19,7 +20,7 @@ const indent = block(open(opener, some(contentline, /^>(?:$|\s)/)), false);
 const unindent = (source: string) => source.replace(/(?<=^|\n)>(?:[^\S\n]|(?=>*(?:$|\s)))|\n$/g, '');
 
 const source: BlockquoteParser.SourceParser = lazy(() => fmap(
-  some(creation(1, false, union([
+  some(creation(0, Recursion.blockquote, union([
     rewrite(
       indent,
       convert(unindent, source, true)),
@@ -30,11 +31,11 @@ const source: BlockquoteParser.SourceParser = lazy(() => fmap(
   ns => [html('blockquote', ns)]));
 
 const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
-  some(creation(1, false, union([
+  some(creation(0, Recursion.blockquote, union([
     rewrite(
       indent,
       convert(unindent, markdown, true)),
-    creation(99, false,
+    creation(10, Recursion.ignore,
     rewrite(
       some(contentline, opener),
       convert(unindent, ({ source, context }) => {

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

@@ -64,7 +64,7 @@ describe('Unit: parser/block/dlist', () => {
       assert.deepStrictEqual(inspect(parser('~ a\n: b\n~ c\n: d\n~ e\n: f')), [['<dl><dt id="index::a">a</dt><dd>b</dd><dt id="index::c">c</dt><dd>d</dd><dt id="index::e">e</dt><dd>f</dd></dl>'], '']);
     });
 
-    it('index', () => {
+    it('indexer', () => {
       assert.deepStrictEqual(inspect(parser('~ a [|b]')), [['<dl><dt id="index::b">a<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a [|b]\\')), [['<dl><dt id="index::a_b">a <span class="invalid">b</span></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ A')), [['<dl><dt id="index::A">A</dt><dd></dd></dl>'], '']);

package/src/parser/block/dlist.ts

@@ -1,6 +1,6 @@
 import { DListParser } from '../block';
-import { union, inits, some, creation, state, block, line, validate, rewrite, open, lazy, fmap } from '../../combinator';
-import { inline, indexee, indexer } from '../inline';
+import { union, inits, some, state, block, line, validate, rewrite, open, lazy, fmap } from '../../combinator';
+import { inline, indexee, indexer, dataindex } from '../inline';
 import { anyline } from '../source';
 import { State } from '../context';
 import { lineable } from '../util';
@@ -17,20 +17,20 @@ export const dlist: DListParser = lazy(() => block(fmap(validate(
   ]))),
   es => [html('dl', fillTrailingDescription(es))])));
 
-const term: DListParser.TermParser = creation(1, false, line(indexee(fmap(open(
+const term: DListParser.TermParser = line(indexee(fmap(open(
   /^~[^\S\n]+(?=\S)/,
   visualize(trimBlankStart(some(union([indexer, inline])))),
   true),
-  ns => [html('dt', trimNodeEnd(defrag(ns)))]))));
+  ns => [html('dt', { 'data-index': dataindex(ns) }, trimNodeEnd(defrag(ns)))])));
 
-const desc: DListParser.DescriptionParser = creation(1, false, block(fmap(open(
+const desc: DListParser.DescriptionParser = block(fmap(open(
   /^:[^\S\n]+(?=\S)|/,
   rewrite(
     some(anyline, /^[~:][^\S\n]+\S/),
     visualize(lineable(some(union([inline]))))),
   true),
   ns => [html('dd', trimNodeEnd(defrag(ns)))]),
-  false));
+  false);
 
 function fillTrailingDescription(es: HTMLElement[]): HTMLElement[] {
   return es.length > 0 && es[es.length - 1].tagName === 'DT'

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

@@ -1,10 +1,11 @@
 import { ExtensionParser } from '../../block';
-import { block, validate, fence, fmap } from '../../../combinator';
+import { creation, block, validate, fence, fmap } from '../../../combinator';
 import { identity } from '../../inline/extension/indexee';
+import { Recursion } from '../../context';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
-export const aside: ExtensionParser.AsideParser = block(validate('~~~', fmap(
+export const aside: ExtensionParser.AsideParser = creation(0, Recursion.block, block(validate('~~~', fmap(
   fence(/^(~{3,})aside(?!\S)([^\n]*)(?:$|\n)/, 300),
   // Bug: Type mismatch between outer and inner.
   ([body, overflow, closer, opener, delim, param]: string[], _, context) => {
@@ -42,4 +43,4 @@ export const aside: ExtensionParser.AsideParser = block(validate('~~~', fmap(
         references,
       ]),
     ];
-  })));
+  }))));

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

@@ -1,13 +1,14 @@
 import { ExtensionParser } from '../../block';
 import { eval } from '../../../combinator/data/parser';
-import { block, validate, fence, fmap } from '../../../combinator';
+import { creation, block, validate, fence, fmap } from '../../../combinator';
 import { parse } from '../../api/parse';
 import { mathblock } from '../mathblock';
+import { Recursion } from '../../context';
 import { html } from 'typed-dom/dom';
 
 const opener = /^(~{3,})(?:example\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/;
 
-export const example: ExtensionParser.ExampleParser = block(validate('~~~', fmap(
+export const example: ExtensionParser.ExampleParser = creation(0, Recursion.block, block(validate('~~~', fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
   ([body, overflow, closer, opener, delim, type = 'markdown', param]: string[], _, context) => {
@@ -58,4 +59,4 @@ export const example: ExtensionParser.ExampleParser = block(validate('~~~', fmap
           }, `${opener}${body}${closer}`),
         ];
     }
-  })));
+  }))));