securemark 0.300.0 → 0.300.1

package/package.json

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

package/src/api/bind.ts

@@ -1,6 +1,6 @@
 import { ParserSettings, Progress } from '../..';
 import { Input, Options, Segment } from '../parser/context';
-import { Output, subinput, run } from '../combinator/parser';
+import { Output, run } from '../combinator/parser';
 import { segment } from '../parser/segment';
 import { block } from '../parser/block';
 import { headers } from './header';
@@ -74,7 +74,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       assert(rev === revision);
       const seg = sourceSegments[index];
       options.segment = sourceSegmentAttrs[index] | Segment.write;
-      for (const _ of run(block, subinput(seg, new Input(options)), output)) {
+      for (const _ of run(block, new Input(options, seg), output)) {
         yield { type: 'break' };
       }
       assert(output.data.length === 1);

package/src/api/parse.ts

@@ -1,5 +1,5 @@
 import { ParserOptions } from '../..';
-import { Input, Options, input } from '../parser/context';
+import { Input, Options } from '../parser/context';
 import { Output, run } from '../combinator/parser';
 import { document } from '../parser/document';
 import { ReadonlyURL } from 'spica/url';
@@ -23,7 +23,7 @@ export function* parse(source: string, opts: Opts = {}, options?: Options): Gene
   if (options.id?.match(/[^0-9a-z/-]/i)) throw new Error('Invalid ID: ID must be alphanumeric');
   if (options.host?.origin === 'null') throw new Error(`Invalid host: ${options.host.href}`);
   const output = new Output<DocumentFragment>();
-  for (const _ of run(document, input(source, new Input(options)), output)) yield;
+  for (const _ of run(document, new Input(options, source), output)) yield;
   assert(output.data.length === 1);
   assert(output.peek().length === 1);
   return output.peek().head!.value;

package/src/combinator/control/inits.ts

@@ -1,16 +1,16 @@
-import { Parser, SubParsers } from '../parser';
+import { Parser, SubParsers, Result } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
-import { recovery } from './state';
 
 export function inits<P extends Parser>(parsers: Parser.SubParsers<P>): P;
 export function inits<T>(parsers: SubParsers<T>): Parser<T> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0:
+      assert(false);
       return (_, output) => output.context;
     case 1:
-      return () => parsers;
+      return parsers[0];
     default:
       return parsers.reduceRight((acc, parser, i) =>
         sequence([
@@ -19,8 +19,17 @@ export function inits<T>(parsers: SubParsers<T>): Parser<T> {
             ? acc
             : union([
                 acc,
-                recovery(),
+                recovery,
               ]),
         ]));
   }
 }
+
+const recovery: Parser<never> = (_, output) => {
+  if (output.state) {
+    output.state = true;
+    // @ts-expect-error
+    output.context ??= Result.succ;
+  }
+  return output.context;
+};

package/src/combinator/control/sequence.ts

@@ -6,8 +6,10 @@ export function sequence<T>(parsers: SubParsers<T>): Parser<T> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0:
+      assert(false);
+      return (_, output) => output.context;
     case 1:
-      return () => parsers;
+      return parsers[0];
     default:
       return parsers.reduceRight((acc, parser) => always([
         parser,

package/src/combinator/control/state.ts

@@ -1,4 +1,4 @@
-import { Parser, SubParsers, Result } from '../parser';
+import { Parser, SubParsers } from '../parser';
 
 export function then<P extends Parser>(success: P, failure: P): P;
 export function then<T>(success: Parser<T>, failure: Parser<T>): Parser<T> {
@@ -31,12 +31,3 @@ export function force<T>(parser: Parser<T>): Parser<T> {
       ? output.context
       : parser(input, output);
 }
-
-export function recovery<P extends Parser>(parser?: P): P;
-export function recovery<T>(parser: Parser<T> = () => Result.succ): Parser<T> {
-  return (input, output) => {
-    output.state = true;
-    output.context = Result.succ;
-    return parser(input, output);
-  };
-}

package/src/combinator/control/union.ts

@@ -1,14 +1,15 @@
-import { Parser, SubParsers } from '../parser';
-import { failure, always, recovery } from './state';
+import { Parser, SubParsers, Result } from '../parser';
+import { failure, always } from './state';
 
 export function union<P extends Parser>(parsers: Parser.SubParsers<P>): P;
 export function union<T>(parsers: SubParsers<T>): Parser<T> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0:
+      assert(false);
       return (_, output) => output.context;
     case 1:
-      return () => parsers;
+      return parsers[0];
     default:
       return parsers.reduceRight((acc, parser) => always([
         parser,
@@ -16,3 +17,15 @@ export function union<T>(parsers: SubParsers<T>): Parser<T> {
       ]));
   }
 }
+
+function recovery<P extends Parser>(parser: P): P;
+function recovery<T>(parser: Parser<T>): Parser<T> {
+  return (input, output) => {
+    if (!output.state) {
+      output.state = true;
+      // @ts-expect-error
+      output.context ??= Result.succ;
+    }
+    return parser(input, output);
+  };
+}

package/src/combinator/parser.ts

@@ -140,7 +140,7 @@ export class Output<T> {
     assert(data.length > 0);
   }
   public state: boolean = true;
-  public context: Result.Succ | Result.Fail = Result.succ;
+  public readonly context: Result.Succ | Result.Fail = Result.succ;
   public error?: Error = undefined;
   public peek(): List<Node<T>> {
     assert(this.data.length > 0);
@@ -222,17 +222,24 @@ export function* run
       time = Date.now();
     }
     if (output.state && output.error) {
-      output.state = false;
-      output.context = Result.fail;
+      if (output.state) {
+        output.state = false;
+        // @ts-expect-error
+        output.context = Result.fail;
+      }
     }
     const input = scope.peek();
     //assert(input.position <= input.source.length);
-    const result = queue.pop()(input, output);
+    const parser = queue.pop();
+    const result = parser(input, output);
 
     if (result) {
       //assert(result.every(f => f));
-      output.state = true;
-      output.context = Result.succ;
+      if (!output.state) {
+        output.state = true;
+        // @ts-expect-error
+        output.context ??= Result.succ;
+      }
       if (result.length !== 0) {
         if (queue.length !== 0) {
           queue.memory = input.memory;
@@ -249,8 +256,11 @@ export function* run
       if (result === Result.skip) {
         queue.length = 0;
       }
-      output.state = false;
-      output.context = Result.fail;
+      if (output.state) {
+        output.state = false;
+        // @ts-expect-error
+        output.context = Result.fail;
+      }
     }
 
     if (queue.length !== 0) continue;

package/src/combinator/process/fence.ts

@@ -2,7 +2,7 @@ import { Parser, SubParsers, Input, List, Node } from '../parser';
 import { spend } from '../effect/clock';
 import { firstline, isEmptyline } from './line';
 
-export function fence<I extends Input, S extends SubParsers<never, I>>(opener: RegExp, write: boolean, limit: number, separation = true): Parser<string, I, S> {
+export function fence<I extends Input, S extends SubParsers<never, I>>(opener: RegExp, write: boolean, separation = true): Parser<string, I, S> {
   assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
   return (input, output) => {
     const { source, position } = input;
@@ -29,11 +29,11 @@ export function fence<I extends Input, S extends SubParsers<never, I>>(opener: R
     for (let count = 1; ; ++count) {
       if (input.position === source.length) break;
       const line = firstline(source, input.position);
-      if ((closer || count > limit + 1) && isEmptyline(line, 0)) break;
+      if (closer && isEmptyline(line, 0)) break;
       if(closer) {
         overflow += line;
       }
-      if (!closer && count <= limit + 1 && line.startsWith(delim) && line.trimEnd() === delim) {
+      if (!closer && line.startsWith(delim) && line.trimEnd() === delim) {
         closer = line;
         if (isEmptyline(source, input.position + line.length)) {
           input.position += line.length;

package/src/combinator/process/surround.ts

@@ -136,6 +136,7 @@ export function surround<T>(
         const o = output.pop();
         if (!g) return;
         output.state = true;
+        // @ts-expect-error
         output.context = Result.succ;
         return g([o, state ? m : undefined], input, output);
       }
@@ -156,6 +157,7 @@ export function surround<T>(
         wbs && setBacktrack(input, wbs, position);
         if (!g) return;
         output.state = true;
+        // @ts-expect-error
         output.context = Result.succ;
         return g([o, state ? m : undefined], input, output);
       }

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

@@ -22,7 +22,6 @@ describe('Unit: parser/block/codeblock', () => {
       assert.deepStrictEqual(inspect(parser, input('```\n````')), [['<pre class="invalid" translate="no">```\n````</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('````\n```')), [['<pre class="invalid" translate="no">````\n```</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input(' ```\n```')), undefined);
-      assert.deepStrictEqual(inspect(parser, input(`\`\`\`\n0${'\n'.repeat(301)}\`\`\``), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('basic', () => {
@@ -44,7 +43,6 @@ describe('Unit: parser/block/codeblock', () => {
       assert.deepStrictEqual(inspect(parser, input('```\n!http://host)\n```')), [['<pre class="text">!<a class="url" href="http://host)" target="_blank">http://host)</a></pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('```\n#a\n```')), [['<pre class="text"><a class="hashtag" href="/hashtags/a">#a</a></pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('```\n@a#b\n```')), [['<pre class="text"><a class="channel" href="/@a?ch=b">@a#b</a></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`\`\`\`\n0${'\n'.repeat(300)}\`\`\``), '>'), [['<pre class="text">'], '']);
     });
 
     it('attribute', () => {

package/src/parser/block/codeblock.ts

@@ -9,13 +9,13 @@ const opener = /(`{3,})(?!`)([^\r\n]*)(?:$|\r?\n)/y;
 const language = /^[0-9a-z]+(?:-[a-z][0-9a-z]*)*$/i;
 
 export const segment: CodeBlockParser.SegmentParser = block(
-  fence(opener, false, 300));
+  fence(opener, false));
 
 export const segment_: CodeBlockParser.SegmentParser = block(
-  fence(opener, false, 300, false), false);
+  fence(opener, false, false), false);
 
 export const codeblock: CodeBlockParser = block(inits([
-  fence(opener, true, 300),
+  fence(opener, true),
   (input, output) => {
     const [body, overflow, closer, opener, delim, param] = unwrap(output.pop()) as string[];
     const params = param.match(/(?:\\.?|\S)+/g)?.reduce<{

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

@@ -11,7 +11,6 @@ describe('Unit: parser/block/extension/aside', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~aside\n~~~')), [['<pre class="invalid" translate="no">~~~aside\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~aside\n# \n~~~')), [['<pre class="invalid" translate="no">~~~aside\n# \n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~aside a\n# 0\n~~~')), [['<pre class="invalid" translate="no">~~~aside a\n# 0\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~aside\n# 0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('valid', () => {

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

@@ -14,7 +14,7 @@ interface Memory {
 }
 
 export const aside: ExtensionParser.AsideParser = block(recursion(Recursion.block, inits([
-  fence(/(~{3,})aside(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true, 300),
+  fence(/(~{3,})aside(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true),
   (input: Input<Memory>, output) => {
     const [body, overflow, closer, opener, delim, param] = unwrap(output.pop()) as string[];
     if (!closer || overflow || param.trimStart()) {

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

@@ -11,7 +11,6 @@ describe('Unit: parser/block/extension/example', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~example/\n~~~')), undefined);
       assert.deepStrictEqual(inspect(parser, input('~~~example/a\n~~~')), [['<pre class="invalid" translate="no">~~~example/a\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~example/markdown a\n~~~')), [['<pre class="invalid" translate="no">~~~example/markdown a\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~example/markdown\n0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('valid', () => {
@@ -27,7 +26,6 @@ describe('Unit: parser/block/extension/example', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~example/markdown\n((a))[[b]]\n~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">((a))[[b]]</pre><hr><section><p><sup class="annotation local" id="annotation:random:ref:a:1" title="a"><a href="#annotation:random:def:a:1">*1</a></sup><sup class="reference local" id="reference:random:ref:b:1" title="b"><a href="#reference:random:def:b">[1]</a></sup></p><ol class="annotations"><li id="annotation:random:def:a:1" data-marker="*1"><span>a</span><sup><a href="#annotation:random:ref:a:1">^1</a></sup></li></ol><h2>References</h2><ol class="references"><li id="reference:random:def:b"><span>b</span><sup><a href="#reference:random:ref:b:1">^1</a></sup></li></ol></section></aside>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~~example/markdown\na\n~~~~')), [['<aside class="example" data-type="markdown"><pre translate="no">a</pre><hr><section><p>a</p><h2>References</h2><ol class="references"></ol></section></aside>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~example/math\na\n~~~')), [['<aside class="example" data-type="math"><pre translate="no">a</pre><hr><div class="math" translate="no">$$\na\n$$</div></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~example/math\n0${'\n'.repeat(100)}~~~`), '>'), [['<aside class="example" data-type="math">'], '']);
     });
 
   });

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

@@ -12,7 +12,7 @@ interface Memory {
 }
 
 export const example: ExtensionParser.ExampleParser = block(recursion(Recursion.block, inits([
-  fence(/(~{3,})(?:example\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true, 300),
+  fence(/(~{3,})(?:example\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true),
   (input: Input<Memory>, output) => {
     const [body, overflow, closer, opener, delim, type = 'markdown', param] = unwrap(output.pop()) as string[];
     if (!closer || overflow || param.trimStart()) return output.append(

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

@@ -33,8 +33,6 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~figure [$fig-name]\n> \n\n~~~')), [['<figure data-type="quote" data-label="fig-name" data-group="fig" class="invalid"><figcaption><span class="figindex"></span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~figure [$figure-name]\n> \n\n~~~')), [['<figure data-type="quote" data-label="figure-name" data-group="figure" class="invalid"><figcaption><span class="figindex"></span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~figure [$table-name]\n> \n\n~~~')), [['<figure data-type="quote" data-label="table-name" data-group="table" class="invalid"><figcaption><span class="figindex"></span><span class="figtext"></span></figcaption><div><blockquote></blockquote></div></figure>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~figure [$group-name]\n0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~figure [$group-name]\n~~~\n0${'\n'.repeat(301)}~~~\n~~~`), '>'), [['<pre class="invalid" translate="no">'], `${'\n'.repeat(300)}~~~\n~~~`]);
     });
 
     it('valid', () => {
@@ -70,8 +68,6 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~figure [$-0.0]\n$$\n\n$$\n~~~')), [['<figure data-type="math" data-label="$-0.0" data-group="$" class="invalid"><figcaption><span class="figindex"></span><span class="figtext"></span></figcaption><div><div class="math" translate="no">$$\n\n$$</div></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~figure [$-name]\n!https://host\n~~~')), [['<figure data-type="media" data-label="$-name" data-group="$" class="invalid"><figcaption><span class="figindex"></span><span class="figtext"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~figure [$-name]\n$$\n\n$$\n\ncaption\n~~~')), [['<figure data-type="math" data-label="$-name" data-group="$" class="invalid"><figcaption><span class="figindex"></span><span class="figtext">caption</span></figcaption><div><div class="math" translate="no">$$\n\n$$</div></div></figure>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~figure [$group-name]\n${'> \n'.repeat(500)}\n~~~`), '>'), [['<figure data-type="quote" data-label="group-name" data-group="group">'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~figure [$group-name]\n~~~\n0${'\n'.repeat(300)}~~~\n~~~`), '>'), [['<figure data-type="example" data-label="group-name" data-group="group">'], '']);
     });
 
   });

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

@@ -84,7 +84,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
     ]);
   })),
   inits([
-    fence(/(~{3,})(?:figure(?=$|[ \r\n])|\[?\$)[^\r\n]*(?:$|\r?\n)/y, true, 300),
+    fence(/(~{3,})(?:figure(?=$|[ \r\n])|\[?\$)[^\r\n]*(?:$|\r?\n)/y, true),
     (_, output) => {
       const [body, overflow, closer, opener, delim] = unwrap(output.pop()) as string[];
       const violation =

package/src/parser/block/extension/message.test.ts

@@ -12,7 +12,6 @@ describe('Unit: parser/block/extension/message', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~message/\n~~~')), undefined);
       assert.deepStrictEqual(inspect(parser, input('~~~message/a\n~~~')), [['<pre class="invalid" translate="no">~~~message/a\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('~~~message/note a\n~~~')), [['<pre class="invalid" translate="no">~~~message/note a\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~message/note\n0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('valid', () => {

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

@@ -20,7 +20,7 @@ import { html } from 'typed-dom/dom';
 import MessageParser = ExtensionParser.MessageParser;
 
 export const message: MessageParser = block(inits([
-  fence(/(~{3,})message\/(\S+)(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true, 300),
+  fence(/(~{3,})message\/(\S+)(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true),
   (input, output) => {
     const [body, overflow, closer, opener, delim, type, param] = unwrap(output.pop()) as string[];
     if (!closer || overflow || param.trimStart()) {

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

@@ -7,13 +7,13 @@ import { html } from 'typed-dom/dom';
 const opener = /(~{3,})(?!~)[^\r\n]*(?:$|\r?\n)/y;
 
 export const segment: ExtensionParser.PlaceholderParser.SegmentParser = block(
-  fence(opener, false, 300));
+  fence(opener, false));
 
 export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(
-  fence(opener, false, 300, false), false);
+  fence(opener, false, false), false);
 
 export const placeholder: ExtensionParser.PlaceholderParser = block(inits([
-  fence(opener, true, 300),
+  fence(opener, true),
   (_, output) => {
     const [body, overflow, closer, opener, delim] = unwrap(output.pop()) as string[];
     return output.append(

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

@@ -10,7 +10,6 @@ describe('Unit: parser/block/extension/table', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~table a\n-\n~~~')), [['<pre class="invalid" translate="no">~~~table a\n-\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~table\n0${'\n'.repeat(10001)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('data', () => {

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

@@ -18,13 +18,13 @@ import CellParser = TableParser.CellParser;
 const opener = /(~{3,})table(?:\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y;
 
 export const segment: TableParser.SegmentParser = block(
-  fence(opener, false, 10000));
+  fence(opener, false));
 
 export const segment_: TableParser.SegmentParser = block(
-  fence(opener, false, 10000, false), false);
+  fence(opener, false, false), false);
 
 export const table: TableParser = block(inits([
-  fence(opener, true, 10000),
+  fence(opener, true),
   (_, output) => {
     const [body, overflow, closer, opener, delim, type, param] = unwrap(output.pop()) as string[];
     if (!closer || overflow || param.trimStart()) return output.append(

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

@@ -25,7 +25,6 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser, input('$$$\n$$')), [['<pre class="invalid" translate="no">$$$\n$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$$$\n$$$')), [['<pre class="invalid" translate="no">$$$\n$$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input(' $$\n$$')), undefined);
-      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(301)}$$`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('basic', () => {
@@ -40,7 +39,6 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser, input('$$\n$$\n\n$$')), [['<div class="math" translate="no">$$\n$$</div>'], '\n$$']);
       assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n$$')), [['<div class="math" translate="no">$$\n$$$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n\n$$')), [['<div class="math" translate="no">$$\n$$$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(300)}$$`), '>'), [['<div class="math" translate="no">'], '']);
     });
 
   });

package/src/parser/block/mathblock.ts

@@ -7,13 +7,13 @@ import { html } from 'typed-dom/dom';
 const opener = /(\${2,})(?!\$)([^\r\n]*)(?:$|\r?\n)/y;
 
 export const segment: MathBlockParser.SegmentParser = block(
-  fence(opener, false, 300));
+  fence(opener, false));
 
 export const segment_: MathBlockParser.SegmentParser = block(
-  fence(opener, false, 300, false), false);
+  fence(opener, false, false), false);
 
 export const mathblock: MathBlockParser = block(inits([
-  fence(opener, true, 300),
+  fence(opener, true),
   ({ caches: { math: cache = undefined } = {} }, output) => {
     const [body, overflow, closer, opener, delim, param] = unwrap(output.pop()) as string[];
     return output.append(

package/src/parser/context.ts

@@ -8,13 +8,14 @@ export function input(source: string, input: Input = new Input()): Input {
 export class Input<M extends object = object> extends Ipt<M> {
   constructor(
     options: Partial<Input> = {},
+    source?: string,
   ) {
     super(options);
     const {
       segment,
       header,
       local,
-      sequential,
+      whitespace,
       host,
       url,
       id,
@@ -22,20 +23,21 @@ export class Input<M extends object = object> extends Ipt<M> {
       caches,
       test,
     } = options;
+    this.source = source ?? options.source ?? '';
     this.resources ??= {
       clock: -1,
       interval: 200,
       recursions: [
-        10 || Recursion.scope,
+        10 || Recursion.document,
         100 || Recursion.block,
         100 || Recursion.inline,
-        100 || Recursion.terminal,
+        100 || Recursion.bracket,
       ],
     };
     this.segment = segment ?? Segment.unknown;
     this.header = header ?? true;
     this.local = local ?? false;
-    this.sequential = sequential ?? false;
+    this.whitespace = whitespace ?? false;
     this.host = host;
     this.url = url;
     this.id = id;
@@ -51,7 +53,7 @@ export class Input<M extends object = object> extends Ipt<M> {
   public override segment: Segment;
   public header: boolean;
   public local: boolean;
-  public sequential: boolean;
+  public whitespace: boolean;
   public recursion = new RecursionCounter(2);
   public readonly host?: URL;
   public readonly url?: URL;
@@ -115,10 +117,10 @@ export const enum State {
 }
 
 export const enum Recursion {
-  scope,
+  document,
   block,
   inline,
-  terminal,
+  bracket,
 }
 
 export const enum Backtrack {
@@ -134,12 +136,7 @@ export const enum Backtrack {
 }
 
 export const enum Command {
-  Error = '\x07',
   Cancel = '\x18',
   Escape = '\x1B',
   Separator = '\x1F',
 }
-
-export const CmdRegExp = {
-  Error: /\x07/g,
-} as const;

package/src/parser/document.ts

@@ -29,7 +29,7 @@ export const document: MarkdownParser = (() => {
       output.push();
       return output.context;
     },
-    recursion(Recursion.scope, force(() => loop)),
+    recursion(Recursion.document, force(() => loop)),
     (input, output) => {
       assert(input.position === input.source.length);
       const doc = frag(unwrap(output.pop()));

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

@@ -39,12 +39,12 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
   ])));
 
 const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => backtrack(union([
-  surround(str('('), recursion(Recursion.terminal, some(union([bracket, unescsource]), ')')), str(')'),
+  surround(str('('), recursion(Recursion.bracket, some(union([bracket, unescsource]), ')')), str(')'),
     true, [3 | Backtrack.unescapable]),
-  surround(str('['), recursion(Recursion.terminal, some(union([bracket, unescsource]), ']')), str(']'),
+  surround(str('['), recursion(Recursion.bracket, some(union([bracket, unescsource]), ']')), str(']'),
     true, [3 | Backtrack.unescapable]),
-  surround(str('{'), recursion(Recursion.terminal, some(union([bracket, unescsource]), '}')), str('}'),
+  surround(str('{'), recursion(Recursion.bracket, some(union([bracket, unescsource]), '}')), str('}'),
     true, [3 | Backtrack.unescapable]),
-  surround(str('"'), precedence(2, recursion(Recursion.terminal, some(unescsource, '"'))), str('"'),
+  surround(str('"'), precedence(2, recursion(Recursion.bracket, some(unescsource, '"'))), str('"'),
     true, [3 | Backtrack.unescapable]),
 ])));

package/src/parser/inline/math.ts

@@ -41,7 +41,7 @@ export const math: MathParser = lazy(() => rewrite(
 
 const bracket: MathParser.BracketParser = lazy(() => backtrack(surround(
   str('{'),
-  recursion(Recursion.terminal,
+  recursion(Recursion.bracket,
   some(union([
     bracket,
     some(escsource, /[{}$\r\n]|(?<=[0-9A-Za-z]):\/\/[[0-9A-Za-z]/y),

package/src/parser/inline/media.ts

@@ -107,13 +107,13 @@ export const media: MediaParser = lazy(() => constraint(State.media, backtrack(o
   })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => union([
-  surround(str('('), recursion(Recursion.terminal, some(union([unsafehtmlentity, bracket, txt]), ')')), str(')'),
+  surround(str('('), recursion(Recursion.bracket, some(union([unsafehtmlentity, bracket, txt]), ')')), str(')'),
     true, [], undefined, () => Result.succ),
-  surround(str('['), recursion(Recursion.terminal, some(union([unsafehtmlentity, bracket, txt]), ']')), str(']'),
+  surround(str('['), recursion(Recursion.bracket, some(union([unsafehtmlentity, bracket, txt]), ']')), str(']'),
     true, [], undefined, () => Result.succ),
-  surround(str('{'), recursion(Recursion.terminal, some(union([unsafehtmlentity, bracket, txt]), '}')), str('}'),
+  surround(str('{'), recursion(Recursion.bracket, some(union([unsafehtmlentity, bracket, txt]), '}')), str('}'),
     true, [], undefined, () => Result.succ),
-  surround(str('"'), precedence(2, recursion(Recursion.terminal, some(union([unsafehtmlentity, txt]), '"'))), str('"'),
+  surround(str('"'), precedence(2, recursion(Recursion.bracket, some(union([unsafehtmlentity, txt]), '"'))), str('"'),
     true, [], undefined, () => Result.succ),
 ]));