securemark 0.255.0 → 0.257.0

package/markdown.d.ts

@@ -1,6 +1,22 @@
 import { Parser, Ctx } from './src/combinator/data/parser';
 import { Dict } from 'spica/dict';
 
+/*
+
+Operator precedence
+
+9: \n, \\\n
+8: `, "
+7: $
+6: (()), [[]]
+5: <tag></tag>
+4: [% %]
+3: (), [], {}
+2: ==, ++, ~~
+1: *, **
+
+*/
+
 declare abstract class Markdown<T> {
   private parser?: T;
 }
@@ -671,7 +687,7 @@ export namespace MarkdownParser {
     export interface AnnotationParser extends
       // ((abc))
       Inline<'annotation'>,
-      Parser<HTMLElement, Context, [
+      Parser<HTMLElement | string, Context, [
         InlineParser,
       ]> {
     }
@@ -680,7 +696,7 @@ export namespace MarkdownParser {
       // [[^abbr]]
       // [[^abbr| abc]]
       Inline<'reference'>,
-      Parser<HTMLElement, Context, [
+      Parser<HTMLElement | string, Context, [
         ReferenceParser.AbbrParser,
         InlineParser,
         InlineParser,
@@ -740,7 +756,6 @@ export namespace MarkdownParser {
         MathParser.BracketParser,
         Parser<string, Context, [
           MathParser.BracketParser,
-          MathParser.QuoteParser,
           SourceParser.StrParser,
         ]>,
       ]> {
@@ -753,14 +768,6 @@ export namespace MarkdownParser {
           SourceParser.EscapableSourceParser,
         ]> {
       }
-      export interface QuoteParser extends
-        Inline<'math/quote'>,
-        Parser<HTMLElement, Context, [
-          QuoteParser,
-          BracketParser,
-          SourceParser.StrParser,
-        ]> {
-      }
     }
     export interface ExtensionParser extends
       // [#abc]

package/package.json

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

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

@@ -9,11 +9,9 @@ import { Parser, Ctx, Tree, Context, eval, exec, check } from '../../data/parser
 
 export function validate<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P): P;
 export function validate<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], has: string, parser: P): P;
-export function validate<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], has: string, end: string, parser: P): P;
-export function validate<T>(patterns: string | RegExp | (string | RegExp)[], has: string | Parser<T>, end?: string | Parser<T>, parser?: Parser<T>): Parser<T> {
-  if (typeof has === 'function') return validate(patterns, '', '', has);
-  if (typeof end === 'function') return validate(patterns, has, '', end);
-  if (!isArray(patterns)) return validate([patterns], has, end!, parser!);
+export function validate<T>(patterns: string | RegExp | (string | RegExp)[], has: string | Parser<T>, parser?: Parser<T>): Parser<T> {
+  if (typeof has === 'function') return validate(patterns, '', has);
+  if (!isArray(patterns)) return validate([patterns], has, parser!);
   assert(patterns.length > 0);
   assert(patterns.every(pattern => pattern instanceof RegExp ? !pattern.flags.match(/[gmy]/) && pattern.source.startsWith('^') : true));
   assert(parser);
@@ -26,17 +24,9 @@ export function validate<T>(patterns: string | RegExp | (string | RegExp)[], has
         ? `|| source.slice(0, ${pattern.length}) === '${pattern}'`
         : `|| /${pattern.source}/${pattern.flags}.test(source)`),
   ].join(''))();
-  const match2 = (source: string): boolean => {
-    if (!has) return true;
-    const i = end ? source.indexOf(end, 1) : -1;
-    return i !== -1
-      ? source.slice(0, i).indexOf(has, 1) !== -1
-      : source.indexOf(has, 1) !== -1;
-  };
   return (source, context) => {
     if (source === '') return;
     if (!match(source)) return;
-    if (!match2(source)) return;
     const result = parser!(source, context);
     assert(check(source, result));
     if (!result) return;

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

@@ -13,20 +13,18 @@ export function guard<T>(f: (context: Ctx) => boolean, parser: Parser<T>): Parse
       : undefined;
 }
 
-export function reset<P extends Parser<unknown>>(context: Context<P>, parser: P): P;
+export function reset<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
 export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
-  if (isEmpty(base)) return parser;
   return (source, context) =>
     parser(source, inherit(ObjectCreate(context), base));
 }
 
-export function context<P extends Parser<unknown>>(context: Context<P>, parser: P): P;
+export function context<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
 export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
-  if (isEmpty(base)) return parser;
   const override = memoize<Ctx, Ctx>(context => inherit(ObjectCreate(context), base), new WeakMap());
   return (source, context) =>
     parser(source, override(context));
@@ -40,6 +38,7 @@ const inherit = template((prop, target, source) => {
   switch (prop) {
     case 'resources':
       assert(typeof source[prop] === 'object');
+      assert(target[prop] || !(prop in target));
       if (prop in target && !hasOwnProperty(target, prop)) return;
       return target[prop] = ObjectCreate(source[prop]);
   }
@@ -59,7 +58,13 @@ const inherit = template((prop, target, source) => {
   }
 });
 
-function isEmpty(context: Ctx): boolean {
-  for (const _ in context) return false;
-  return true;
+export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
+export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
+  return (source, context) => {
+    const p = context.precedence;
+    context.precedence = precedence;
+    const result = parser(source, context);
+    context.precedence = p;
+    return result;
+  };
 }

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

@@ -4,11 +4,11 @@ export function creator<P extends Parser<unknown>>(parser: P): P;
 export function creator<P extends Parser<unknown>>(cost: number, parser: P): P;
 export function creator(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
   if (typeof cost === 'function') return creator(1, cost);
-  assert(cost > 0);
+  assert(cost >= 0);
   return (source, context) => {
     const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations.');
-    if (resources.recursion <= 0) throw new Error('Too much recursion.');
+    if (resources.budget <= 0) throw new Error('Too many creations');
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
     --resources.recursion;
     const result = parser!(source, context);
     ++resources.recursion;
@@ -18,3 +18,37 @@ export function creator(cost: number | Parser<unknown>, parser?: Parser<unknown>
     return result;
   };
 }
+
+export function uncreator<P extends Parser<unknown>>(parser: P): P;
+export function uncreator<P extends Parser<unknown>>(cost: number, parser: P): P;
+export function uncreator(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
+  if (typeof cost === 'function') return uncreator(1, cost);
+  assert(cost >= 0);
+  return (source, context) => {
+    const { resources = { budget: 1, recursion: 1 } } = context;
+    if (resources.budget <= 0) throw new Error('Too many creations');
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
+    ++resources.recursion;
+    const result = parser!(source, context);
+    --resources.recursion;
+    if (result) {
+      resources.budget += cost;
+    }
+    return result;
+  };
+}
+
+export function recursion<P extends Parser<unknown>>(parser: P): P;
+export function recursion<P extends Parser<unknown>>(cost: number, parser: P): P;
+export function recursion(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
+  if (typeof cost === 'function') return recursion(1, cost);
+  assert(cost >= 0);
+  return (source, context) => {
+    const { resources = { recursion: 1 } } = context;
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
+    --resources.recursion;
+    const result = parser!(source, context);
+    ++resources.recursion;
+    return result;
+  };
+}

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

@@ -6,27 +6,27 @@ 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,
   f?: (rss: [S[], SubTree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], SubTree<P>[]], 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>>,
 ): 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,
   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], 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>>,
 ): 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,
   f?: (rss: [S[], Tree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], Tree<P>[]], 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>>,
 ): 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,
   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], 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>>,
 ): P;
 export function surround<T>(
   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[]], rest: string, context: Ctx) => Result<T>,
+  g?: (rss: [T[], T[], string], rest: string, context: Ctx) => Result<T>,
 ): Parser<T> {
   switch (typeof opener) {
     case 'string':
@@ -60,7 +60,7 @@ export function surround<T>(
         ? f([rl, rm!, rr], rest, context)
         : [push(unshift(rl, rm ?? []), rr), rest]
       : g
-        ? g([rl, rm!], rest, context)
+        ? g([rl, rm!, mr_], rest, context)
         : undefined;
   };
 }

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

@@ -14,7 +14,7 @@ export function inits<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) break;
-      assert(!context?.delimiters?.match(rest));
+      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);

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

@@ -14,7 +14,7 @@ export function sequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) return;
-      assert(!context?.delimiters?.match(rest));
+      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);

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

@@ -3,6 +3,8 @@ import { Parser, Delimiters, eval, exec, check } from '../parser';
 import { memoize, reduce } from 'spica/memoize';
 import { push } from 'spica/array';
 
+type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
+
 const signature = (pattern: string | RegExp | undefined): string => {
   switch (typeof pattern) {
     case 'undefined':
@@ -26,31 +28,29 @@ const matcher = memoize(
   },
   signature);
 
-export function some<P extends Parser<unknown>>(parser: P, until?: string | RegExp | number, deep?: string | RegExp, limit?: number): P;
-export function some<T>(parser: Parser<T>, until?: string | RegExp | number, deep?: string | RegExp, limit = -1): Parser<T> {
+export function some<P extends Parser<unknown>>(parser: P, until?: string | RegExp | number, deeps?: readonly DelimiterOption[], limit?: number): P;
+export function some<T>(parser: Parser<T>, until?: string | RegExp | number, deeps: readonly DelimiterOption[] = [], limit = -1): Parser<T> {
+  if (typeof until === 'number') return some(parser, undefined, deeps, until);
   assert(parser);
-  assert(until instanceof RegExp ? !until.flags.match(/[gmy]/) && until.source.startsWith('^') : true);
-  assert(deep instanceof RegExp ? !deep.flags.match(/[gmy]/) && deep.source.startsWith('^') : true);
-  if (typeof until === 'number') return some(parser, undefined, deep, until);
+  assert([until].concat(deeps.map(o => o[0])).every(d => d instanceof RegExp ? !d.flags.match(/[gmy]/) && d.source.startsWith('^') : true));
   const match = matcher(until);
-  const delimiter = {
-    signature: signature(deep),
-    matcher: matcher(deep),
-  } as const;
+  const delimiters = deeps.map(([delimiter, precedence]) => ({
+    signature: signature(delimiter),
+    matcher: matcher(delimiter),
+    precedence,
+  }));
   return (source, context) => {
     if (source === '') return;
     let rest = source;
     let nodes: T[] | undefined;
-    if (deep && context) {
-      // bracket > link > media | bracket
-      // bracket > index > bracket
+    if (delimiters.length > 0) {
       context.delimiters ??= new Delimiters();
-      context.delimiters.push(delimiter);
+      context.delimiters.push(...delimiters);
     }
     while (true) {
       if (rest === '') break;
       if (match(rest)) break;
-      if (context.delimiters?.match(rest)) break;
+      if (context.delimiters?.match(rest, context.precedence)) break;
       const result = parser(rest, context);
       assert.doesNotThrow(() => limit < 0 && check(rest, result));
       if (!result) break;
@@ -60,8 +60,8 @@ export function some<T>(parser: Parser<T>, until?: string | RegExp | number, dee
       rest = exec(result);
       if (limit >= 0 && source.length - rest.length > limit) break;
     }
-    if (deep && context.delimiters) {
-      context.delimiters.pop();
+    if (delimiters.length > 0) {
+      context.delimiters!.pop(delimiters.length);
     }
     assert(rest.length <= source.length);
     return nodes && rest.length < source.length
@@ -69,25 +69,3 @@ export function some<T>(parser: Parser<T>, until?: string | RegExp | number, dee
       : undefined;
   };
 }
-
-export function escape<P extends Parser<unknown>>(parser: P, delim: string): P;
-export function escape<T>(parser: Parser<T>, delim: string): Parser<T> {
-  assert(parser);
-  const delimiter = {
-    signature: signature(delim),
-    matcher: (source: string) => source.slice(0, delim.length) !== delim && undefined,
-    escape: true,
-  } as const;
-  return (source, context) => {
-    if (source === '') return;
-    if (context) {
-      context.delimiters ??= new Delimiters();
-      context.delimiters.push(delimiter);
-    }
-    const result = parser(source, context);
-    if (context.delimiters) {
-      context.delimiters.pop();
-    }
-    return result;
-  };
-}

package/src/combinator/data/parser.ts

@@ -1,5 +1,3 @@
-import { undefined } from 'spica/global';
-
 export type Parser<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   = (source: string, context: C) => Result<T, C, D>;
 export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
@@ -11,6 +9,7 @@ export interface Ctx {
     budget: number;
     recursion: number;
   };
+  precedence?: number;
   delimiters?: Delimiters;
 }
 export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;
@@ -22,28 +21,44 @@ type ExtractSubTree<D extends Parser<unknown>[]> = ExtractSubParser<D> extends i
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
 export class Delimiters {
-  private readonly matchers: ((source: string) => boolean | undefined)[] = [];
-  private readonly record: Record<string, boolean> = {};
-  public push(delimiter: { readonly signature: string; readonly matcher: (source: string) => boolean | undefined; readonly escape?: boolean; }): void {
-    const { signature, matcher, escape } = delimiter;
-    if (this.record[signature] === !escape) {
-      this.matchers.unshift(() => undefined);
-    }
-    else {
-      this.matchers.unshift(matcher);
-      this.record[signature] = !escape;
+  private readonly matchers: [number, string, number, (source: string) => boolean | undefined][] = [];
+  private readonly registry: Record<string, boolean> = {};
+  private length = 0;
+  public push(
+    ...delimiters: 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;
+      }
+      ++this.length;
     }
   }
-  public pop(): void {
-    assert(this.matchers.length > 0);
-    this.matchers.shift();
+  public pop(count = 1): void {
+    assert(count > 0);
+    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;
+      }
+    }
   }
-  public match(source: string): boolean {
+  public match(source: string, precedence = 1): boolean {
     const { matchers } = this;
     for (let i = 0; i < matchers.length; ++i) {
-      switch (matchers[i](source)) {
+      switch (matchers[i][3](source)) {
         case true:
-          return true;
+          if (precedence < matchers[i][2]) return true;
+          continue;
         case false:
           return false;
       }
@@ -73,6 +88,7 @@ export function exec(result: Result<unknown>, default_?: string): string | undef
 
 export function check(source: string, result: Result<unknown>, mustConsume = true): true {
   assert.doesNotThrow(() => {
+    if (source.length > 1000) return;
     if (source.slice(+mustConsume).slice(-exec(result, '').length || source.length) !== exec(result, '')) throw new Error();
   });
   return true;

package/src/debug.test.ts

@@ -4,8 +4,8 @@ import { querySelector, querySelectorAll } from 'typed-dom/query';
 
 export function inspect(result: Result<HTMLElement | string>, until: number | string = Infinity): Result<string> {
   return result && [
-    eval(result).map(node => {
-      assert(node);
+    eval(result).map((node, i, nodes) => {
+      assert(node || node === '' && '([{'.includes(nodes[i + 1] as string));
       if (typeof node === 'string') return node;
       node = node.cloneNode(true);
       assert(!querySelector(node, '.invalid[data-invalid-message$="."]'));

package/src/parser/api/bind.ts

@@ -1,5 +1,4 @@
 import { undefined, location } from 'spica/global';
-import { ObjectAssign, ObjectCreate } from 'spica/alias';
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
@@ -21,11 +20,10 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   nearest: (position: number) => HTMLElement | undefined;
   index: (block: HTMLElement) => number;
 } {
-  const context: MarkdownParser.Context = ObjectAssign(ObjectCreate(settings), {
+  let context: MarkdownParser.Context = {
+    ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
-    footnotes: undefined,
-    chunk: undefined,
-  });
+  };
   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];
@@ -41,14 +39,14 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   };
 
   function* parse(source: string): Generator<Progress, undefined, undefined> {
-    if (settings.chunk && revision) throw new Error('Chunks cannot be updated.');
+    if (settings.chunk && revision) throw new Error('Chunks cannot be updated');
     const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
     source = normalize(validate(source, MAX_INPUT_SIZE) ? source : source.slice(0, MAX_INPUT_SIZE + 1));
-    ObjectAssign<MarkdownParser.Context, MarkdownParser.Context>(
-      context,
-      {
-        url: url ? new ReadonlyURL(url as ':') : undefined,
-      });
+    // Change the object identity.
+    context = {
+      ...context,
+      url: url ? new ReadonlyURL(url as ':') : undefined,
+    };
     const rev = revision = Symbol();
     const sourceSegments: string[] = [];
     for (const seg of segment(source)) {

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

@@ -223,22 +223,64 @@ describe('Unit: parser/api/parse', () => {
         ['<p>a<span class="linebreak"> </span>b</p>']);
     });
 
-    it('creation', () => {
+    it('backtrack', () => {
       assert.deepStrictEqual(
-        [...parse('"[% '.repeat(100)).children].map(el => el.outerHTML),
-        [`<p>${'"[% '.repeat(100).trim()}</p>`]);
+        [...parse('"[% '.repeat(100) + '\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(100)}\n</pre>`,
+          '<p>a</p>',
+        ]);
     });
 
     it('recursion', () => {
       assert.deepStrictEqual(
-        [...parse('('.repeat(199)).children].map(el => el.outerHTML),
-        [`<p>${'('.repeat(199)}</p>`]);
+        [...parse('('.repeat(20)).children].map(el => el.outerHTML),
+        [`<p>${'('.repeat(20)}</p>`]);
       assert.deepStrictEqual(
-        [...parse('('.repeat(200) + '\n\na').children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse('('.repeat(21)).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(200)}\n</pre>`,
-          '<p>a</p>',
+          '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
+          `<pre class="error" translate="no">${'('.repeat(21)}</pre>`,
+        ]);
+      assert.deepStrictEqual(
+        [...parse('['.repeat(20)).children].map(el => el.outerHTML),
+        [`<p>${'['.repeat(20)}</p>`]);
+      assert.deepStrictEqual(
+        [...parse('['.repeat(21)).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>`,
+        ]);
+      assert.deepStrictEqual(
+        [...parse('{'.repeat(20)).children].map(el => el.outerHTML),
+        [`<p>${'{'.repeat(20)}</p>`]);
+      assert.deepStrictEqual(
+        [...parse('{'.repeat(21)).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>`,
+        ]);
+    });
+
+    if (!navigator.userAgent.includes('Chrome')) return;
+
+    it('creation', function () {
+      this.timeout(5000);
+      // 実測500ms程度
+      assert.deepStrictEqual(
+        [...parse('.'.repeat(50000)).children].map(el => el.outerHTML),
+        [`<p>${'.'.repeat(50000)}</p>`]);
+    });
+
+    it('creation error', function () {
+      this.timeout(5000);
+      // 実測500ms程度
+      assert.deepStrictEqual(
+        [...parse('.'.repeat(50001)).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

@@ -1,4 +1,4 @@
-import { undefined, location } from 'spica/global';
+import { location } from 'spica/global';
 import { ParserOptions } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
@@ -22,12 +22,13 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
   source = !context ? normalize(source) : source;
   assert(!context?.delimiters);
   context = {
-    url: url ? new ReadonlyURL(url as ':') : context?.url,
     host: opts.host ?? context?.host ?? new ReadonlyURL(location.pathname, location.origin),
+    url: url ? new ReadonlyURL(url as ':') : context?.url,
+    id: opts.id ?? context?.id,
     caches: context?.caches,
-    footnotes: undefined,
-    test: undefined,
-    ...opts,
+    ...context?.resources && {
+      resources: context.resources,
+    },
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   const node = frag();

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

@@ -1,10 +1,10 @@
 import { ExtensionParser } from '../../block';
-import { block, validate, fence, creator, fmap } from '../../../combinator';
+import { block, validate, fence, fmap } from '../../../combinator';
 import { identity, text } from '../../inline/extension/indexee';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
-export const aside: ExtensionParser.AsideParser = creator(100, block(validate('~~~', fmap(
+export const aside: ExtensionParser.AsideParser = 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) => {
@@ -43,4 +43,4 @@ export const aside: ExtensionParser.AsideParser = creator(100, block(validate('~
         references,
       ]),
     ];
-  }))));
+  })));

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

@@ -1,13 +1,13 @@
 import { ExtensionParser } from '../../block';
 import { eval } from '../../../combinator/data/parser';
-import { block, validate, fence, creator, fmap } from '../../../combinator';
+import { block, validate, fence, fmap } from '../../../combinator';
 import { parse } from '../../api/parse';
 import { mathblock } from '../mathblock';
 import { html } from 'typed-dom/dom';
 
 const opener = /^(~{3,})(?:example\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/;
 
-export const example: ExtensionParser.ExampleParser = creator(100, block(validate('~~~', fmap(
+export const example: ExtensionParser.ExampleParser = 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 +58,4 @@ export const example: ExtensionParser.ExampleParser = creator(100, block(validat
           }, `${opener}${body}${closer}`),
         ];
     }
-  }))));
+  })));

package/src/parser/block.ts

@@ -36,7 +36,7 @@ export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
 export const block: BlockParser = creator(error(
-  reset({ resources: { budget: 100 * 1000, recursion: 200 } },
+  reset({ resources: { budget: 50 * 1000, recursion: 20 + 1 } },
   union([
     emptyline,
     horizontalrule,