securemark 0.300.0 → 0.300.2

package/index.d.ts

@@ -44,7 +44,7 @@ export type Progress =
   | { readonly type: 'block'; readonly value: HTMLElement; }
   | { readonly type: 'figure'; readonly value: HTMLAnchorElement; }
   | { readonly type: 'note'; readonly value: HTMLLIElement | HTMLElement; }
-  | { readonly type: 'break'; }
+  | { readonly type: 'break'; readonly value: 'segment' | 'block' | 'parser' | 'figure' | 'note'; }
   | { readonly type: 'cancel'; };
 
 export interface RenderingOptions {

package/markdown.d.ts

@@ -325,7 +325,6 @@ export namespace MarkdownParser {
         Parser<string, Input, [
           FigParser.SegmentParser,
           FigureParser.SegmentParser,
-          TableParser.SegmentParser,
           PlaceholderParser.SegmentParser,
         ]> {
       }
@@ -350,8 +349,8 @@ export namespace MarkdownParser {
               MathBlockParser,
               ExampleParser,
               TableParser,
-              BlockquoteParser,
               PlaceholderParser,
+              BlockquoteParser,
               InlineParser.MediaParser,
               InlineParser.ShortMediaParser.LineShortMediaParser,
             ]>,
@@ -369,9 +368,8 @@ export namespace MarkdownParser {
               Parser<never, Input, [
                 CodeBlockParser.SegmentParser,
                 MathBlockParser.SegmentParser,
-                TableParser.SegmentParser,
-                BlockquoteParser.SegmentParser,
                 PlaceholderParser.SegmentParser,
+                BlockquoteParser.SegmentParser,
                 SourceParser.ContentLineParser,
               ]>,
               SourceParser.EmptyLineParser,
@@ -399,9 +397,8 @@ export namespace MarkdownParser {
             Parser<never, Input, [
               CodeBlockParser.SegmentParser,
               MathBlockParser.SegmentParser,
-              TableParser.SegmentParser,
-              BlockquoteParser.SegmentParser,
               PlaceholderParser.SegmentParser,
+              BlockquoteParser.SegmentParser,
               SourceParser.ContentLineParser,
             ]>,
           ]> {
@@ -427,10 +424,6 @@ export namespace MarkdownParser {
         ]> {
       }
       export namespace TableParser {
-        export interface SegmentParser extends
-          Block<'extension/table/segment'>,
-          Parser<never, Input, []> {
-        }
         export interface GridTableParser extends
           Block<'extension/table/gridtable'>,
           Parser<HTMLElement, Input, [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.300.0",
+  "version": "0.300.2",
   "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,8 +74,8 @@ 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)) {
-        yield { type: 'break' };
+      for (const _ of run(block, new Input(options, seg), output)) {
+        yield { type: 'break', value: 'block' };
       }
       assert(output.data.length === 1);
       const es = output.pop()
@@ -124,20 +124,20 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       yield { type: 'block', value: el };
       if (rev !== revision) return yield { type: 'cancel' };
     }
-    yield { type: 'break' };
+    yield { type: 'break', value: 'parser' };
     if (rev !== revision) return yield { type: 'cancel' };
     for (const el of figure(next(0)?.parentNode ?? target, settings.notes, options)) {
       assert(rev === revision);
       el
         ? yield { type: 'figure', value: el }
-        : yield { type: 'break' };
+        : yield { type: 'break', value: 'figure' };
       if (rev !== revision) return yield { type: 'cancel' };
     }
     for (const el of note(next(0)?.parentNode ?? target, settings.notes, options, bottom)) {
       assert(rev === revision);
       el
         ? yield { type: 'note', value: el }
-        : yield { type: 'break' };
+        : yield { type: 'break', value: 'note' };
       if (rev !== revision) return yield { type: 'cancel' };
     }
   }

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,15 +2,15 @@ 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;
-    if (position === source.length) return;
-    opener.lastIndex = position;
+    const { source } = input;
+    if (input.position === source.length) return;
+    opener.lastIndex = input.position;
     const matches = opener.exec(source);
     if (!matches) return;
-    assert(matches[0] === firstline(source, position));
+    assert(matches[0] === firstline(source, input.position));
     spend(input, output, matches[0].length);
     const delim = matches[1];
     assert(delim && delim === delim.trim());
@@ -23,37 +23,27 @@ export function fence<I extends Input, S extends SubParsers<never, I>>(opener: R
       input.position -= matches[0].length;
       return;
     }
+    const { position } = input;
     let body = '';
     let closer = '';
-    let overflow = '';
-    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) {
-        overflow += line;
-      }
-      if (!closer && count <= limit + 1 && line.startsWith(delim) && line.trimEnd() === delim) {
-        closer = line;
-        if (isEmptyline(source, input.position + line.length)) {
-          input.position += line.length;
-          break;
-        }
-        if (!separation) {
-          input.position += line.length;
-          break;
-        }
-        assert(!overflow);
-        overflow = line;
-      }
-      if (!overflow) {
-        body += line;
-      }
-      input.position += line.length;
+    assert(matches[0].endsWith('\n'));
+    for (input.position -= 1; ;) {
+      input.position = source.indexOf(`\n${delim}`, input.position) + 1 || source.length;
+      if (!isEmptyline(source, input.position + delim.length)) continue;
+      body = source.slice(position, input.position);
+      closer = firstline(source, input.position);
+      input.position += closer.length;
+      break;
+    }
+    if (separation) for (; !isEmptyline(source, input.position);) {
+      input.position = source.indexOf('\n', input.position) + 1 || source.length;
+    }
+    if (write) {
+      const overflow = source.slice(position + body.length + closer.length, input.position);
+      output.push(
+        new List([body, overflow, closer].map(str => new Node(str)))
+          .import(new List(matches.map(str => new Node(str)))));
     }
-    write && output.push(
-      new List([body, overflow, closer].map(str => new Node(str)))
-        .import(new List(matches.map(str => new Node(str)))));
     return output.context;
   };
 }

package/src/combinator/process/line.ts

@@ -49,7 +49,7 @@ export function firstline(source: string, position: number): string {
 const emptyline = /[^\S\r\n]*(?:$|\r?\n)/y;
 export function isEmptyline(source: string, position: number): boolean {
   emptyline.lastIndex = position;
-  return source.length === position
+  return position >= source.length
       || source[position] === '\n'
       || emptyline.test(source);
 }

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<{
@@ -64,7 +64,7 @@ export const codeblock: CodeBlockParser = block(inits([
                   ? `Invalid trailing line after the closing delimiter "${delim}"`
                   : params.invalid!),
           },
-          `${opener}${body}${overflow || closer}`)));
+          `${opener}${body}${closer}${overflow}`)));
       return;
     }
     const src = body.slice(0, body.at(-2) === '\r' ? -2 : -1);

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()) {
@@ -30,7 +30,7 @@ export const aside: ExtensionParser.AsideParser = block(recursion(Recursion.bloc
                 overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
                   'Invalid argument'),
           },
-          `${opener}${body}${overflow || closer}`)));
+          `${opener}${body}${closer}${overflow}`)));
       return;
     }
     input.memory = {

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(
@@ -27,7 +27,7 @@ export const example: ExtensionParser.ExampleParser = block(recursion(Recursion.
               overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
                 'Invalid argument'),
         },
-        `${opener}${body}${overflow || closer}`)));
+        `${opener}${body}${closer}${overflow}`)));
     switch (type) {
       case 'markdown': {
         input.memory = {

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

@@ -1,30 +1,28 @@
 import { ExtensionParser } from '../../block';
 import { Segment } from '../../context';
 import { Result } from '../../../combinator/parser';
-import { union, sequence, some, always, backtrack, block, line, rewrite, close } from '../../../combinator';
+import { union, sequence, some, always, block, line, rewrite, close } from '../../../combinator';
 import { contentline } from '../../source';
 import { figure } from './figure';
 import { segment as seg_label } from '../../inline/extension/label';
 import { segment as seg_code } from '../codeblock';
 import { segment as seg_math } from '../mathblock';
-import { segment as seg_table } from './table';
-import { segment as seg_blockquote } from '../blockquote';
 import { segment as seg_placeholder } from './placeholder';
+import { segment as seg_blockquote } from '../blockquote';
 
 import FigParser = ExtensionParser.FigParser;
 
-export const segment: FigParser.SegmentParser = backtrack(block(
+export const segment: FigParser.SegmentParser = block(
   sequence([
     line(close(seg_label, /(?!\S)[^\r\n]*\r?\n/y), false),
     union([
       seg_code,
       seg_math,
-      seg_table,
-      seg_blockquote,
       seg_placeholder,
+      seg_blockquote,
       some(contentline),
     ]),
-  ]), true, Segment.fig));
+  ]), true, Segment.fig);
 
 export const fig: FigParser = block(rewrite(segment, always([
   (input, output) => {

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

@@ -10,9 +10,9 @@ import { table as styled_table } from '../table';
 import { codeblock, segment_ as seg_code } from '../codeblock';
 import { mathblock, segment_ as seg_math } from '../mathblock';
 import { example } from './example';
-import { table, segment_ as seg_table } from './table';
-import { blockquote, segment as seg_blockquote } from '../blockquote';
+import { table } from './table';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
+import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { inline, media, lineshortmedia } from '../../inline';
 import { visualize, trimBlank } from '../../visibility';
 import { unwrap, invalid } from '../../util';
@@ -32,9 +32,8 @@ export const segment: FigureParser.SegmentParser = block(match(
         union([
           seg_code,
           seg_math,
-          seg_table,
-          seg_blockquote,
           seg_placeholder,
+          seg_blockquote,
           some(contentline, closer),
         ]),
         emptyline,
@@ -60,8 +59,8 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
         mathblock,
         example,
         table,
-        blockquote,
         placeholder,
+        blockquote,
         line(media, false),
         line(lineshortmedia, false),
       ])),
@@ -84,7 +83,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 =
@@ -115,7 +114,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
             translate: 'no',
             ...invalid('figure', violation[0], violation[1]),
           },
-          `${opener}${body}${overflow || closer}`)));
+          `${opener}${body}${closer}${overflow}`)));
     },
   ])));
 

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()) {
@@ -36,7 +36,7 @@ export const message: MessageParser = block(inits([
                 overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
                   'Invalid argument'),
           },
-          `${opener}${body}${overflow || closer}`)));
+          `${opener}${body}${closer}${overflow}`)));
       return;
     }
     switch (type) {