securemark 0.243.1 → 0.244.1

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

@@ -2,36 +2,46 @@ import { Parser, Ctx } from '../../data/parser';
 import { firstline, isEmpty } from '../constraint/line';
 import { unshift } from 'spica/array';
 
-export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation: boolean = true): Parser<string, C, D> {
+export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation = true): Parser<string, C, D> {
   return source => {
     if (source === '') return;
     const matches = source.match(opener);
     if (!matches) return;
     assert(matches[0] === firstline(source));
     const delim = matches[1];
+    assert(delim && delim === delim.trim());
     if (matches[0].indexOf(delim, delim.length) !== -1) return;
     let rest = source.slice(matches[0].length);
     // Prevent annoying parsing in editing.
     if (isEmpty(firstline(rest)) && firstline(rest.slice(firstline(rest).length)).trimEnd() !== delim) return;
     let block = '';
     let closer = '';
-    for (let count = 1, next = firstline(rest); ; ++count) {
+    let overflow = '';
+    for (let count = 1; ; ++count) {
       if (rest === '') break;
-      const line = next;
-      next = firstline(rest.slice(line.length));
-      if (count > limit + 1 && isEmpty(line)) break;
-      if (count <= limit + 1 &&
-          line.slice(0, delim.length) === delim &&
-          line.trimEnd() === delim &&
-          (!separation || isEmpty(next))) {
-        assert(line.trimEnd() === delim);
-        closer = delim;
-        rest = rest.slice(line.length);
-        break;
+      const line = firstline(rest);
+      if ((closer || count > limit + 1) && isEmpty(line)) break;
+      if(closer) {
+        overflow += line;
+      }
+      if (!closer && count <= limit + 1 && line.slice(0, delim.length) === delim && line.trimEnd() === delim) {
+        closer = line;
+        if (isEmpty(firstline(rest.slice(line.length)))) {
+          rest = rest.slice(line.length);
+          break;
+        }
+        if (!separation) {
+          rest = rest.slice(line.length);
+          break;
+        }
+        assert(!overflow);
+        overflow = line;
+      }
+      if (!overflow) {
+        block += line;
       }
-      block += line;
       rest = rest.slice(line.length);
     }
-    return [unshift([block, closer], matches), rest];
+    return [unshift([block, overflow, closer], matches), rest];
   };
 }

package/src/combinator/data/parser.ts

@@ -1,3 +1,5 @@
+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>

package/src/debug.test.ts

@@ -1,5 +1,6 @@
 import { Result, eval, exec } from './combinator/data/parser';
 import { html, define } from 'typed-dom/dom';
+import { querySelector, querySelectorAll } from 'typed-dom/query';
 
 export function inspect(result: Result<HTMLElement | string>, until: number | string = Infinity): Result<string> {
   return result && [
@@ -7,14 +8,15 @@ export function inspect(result: Result<HTMLElement | string>, until: number | st
       assert(node);
       if (typeof node === 'string') return node;
       node = node.cloneNode(true);
-      assert(!node.matches('.invalid[data-invalid-message$="."]'));
-      assert(!node.querySelector('.invalid[data-invalid-message$="."]'));
-      [node, ...node.querySelectorAll('.invalid')].forEach(el =>
+      assert(!querySelector(node, '.invalid[data-invalid-message$="."]'));
+      querySelectorAll(node, '.invalid').forEach(el => {
+        assert(el.matches('[data-invalid-syntax][data-invalid-type][data-invalid-message]'));
         define(el, {
           'data-invalid-syntax': null,
           'data-invalid-type': null,
           'data-invalid-message': null,
-        }));
+        });
+      });
       until = typeof until === 'number'
         ? until
         : ~(~node.outerHTML.indexOf(until) || -Infinity) + until.length;

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

@@ -17,6 +17,7 @@ describe('Unit: parser/block/codeblock', () => {
       assert.deepStrictEqual(inspect(parser('```\na\n```\nb')), [['<pre class="invalid" translate="no">```\na\n```\nb</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```\n\n\n```')), undefined);
       assert.deepStrictEqual(inspect(parser('```a ```\n```')), undefined);
+      assert.deepStrictEqual(inspect(parser('```\n```\n```')), [['<pre class="invalid" translate="no">```\n```\n```</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```\n````')), [['<pre class="invalid" translate="no">```\n````</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('````\n```')), [['<pre class="invalid" translate="no">````\n```</pre>'], '']);
       assert.deepStrictEqual(inspect(parser(' ```\n```')), undefined);
@@ -30,7 +31,6 @@ describe('Unit: parser/block/codeblock', () => {
       assert.deepStrictEqual(inspect(parser('```\na\nb\n```')), [['<pre class="text">a<br>b</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```\n\\\n```')), [['<pre class="text">\\</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```\n`\n```')), [['<pre class="text">`</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n```\n```')), [['<pre class="text">```</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```\n```\n\n```')), [['<pre class="text"></pre>'], '\n```']);
       assert.deepStrictEqual(inspect(parser('```\n````\n```')), [['<pre class="text">````</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```\n````\n\n```')), [['<pre class="text">````<br></pre>'], '']);

package/src/parser/block/codeblock.ts

@@ -17,7 +17,7 @@ export const segment_: CodeBlockParser.SegmentParser = block(validate('```',
 export const codeblock: CodeBlockParser = block(validate('```', fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, param]: string[], _, context) => {
+  ([body, overflow, closer, opener, delim, param]: string[], _, context) => {
     const params = param.match(/(?:\\.?|\S)+/g)?.reduce<{
       lang?: string;
       path?: string;
@@ -45,17 +45,20 @@ export const codeblock: CodeBlockParser = block(validate('```', fmap(
           }
       }
       name in params
-        ? params.invalid = `Duplicate ${name} value`
+        ? params.invalid = `Duplicate ${name} attribute`
         : params[name] = value;
       return params;
     }, {}) ?? {};
-    if (!closer || params.invalid) return [html('pre', {
+    if (!closer || overflow || params.invalid) return [html('pre', {
       class: 'invalid',
       translate: 'no',
       'data-invalid-syntax': 'codeblock',
-      'data-invalid-type': !closer ? 'fence' : 'argument',
-      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : params.invalid,
-    }, `${opener}${body}${closer}`)];
+      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
+      'data-invalid-message':
+        !closer ? `Missing the closing delimiter "${delim}"` :
+        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
+        params.invalid,
+    }, `${opener}${body}${overflow || closer}`)];
     const el = html('pre',
       {
         class: params.lang ? `code language-${params.lang}` : 'text',

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

@@ -7,14 +7,17 @@ import { html } from 'typed-dom/dom';
 export const aside: ExtensionParser.AsideParser = creator(100, block(validate('~~~', fmap(
   fence(/^(~{3,})aside(?!\S)([^\n]*)(?:$|\n)/, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, param]: string[], _, context) => {
-    if (!closer || param.trimStart()) return [html('pre', {
+  ([body, overflow, closer, opener, delim, param]: string[], _, context) => {
+    if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
       'data-invalid-syntax': 'aside',
-      'data-invalid-type': !closer ? 'fence' : 'argument',
-      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid argument',
-    }, `${opener}${body}${closer}`)];
+      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
+      'data-invalid-message':
+        !closer ? `Missing the closing delimiter "${delim}"` :
+        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
+        'Invalid argument',
+    }, `${opener}${body}${overflow || closer}`)];
     const annotations = html('ol', { class: 'annotations' });
     const references = html('ol', { class: 'references' });
     const document = parse(body.slice(0, -1), {

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

@@ -10,14 +10,17 @@ const opener = /^(~{3,})(?:example\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/;
 export const example: ExtensionParser.ExampleParser = creator(100, block(validate('~~~', fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, type = 'markdown', param]: string[], _, context) => {
-    if (!closer || param.trimStart()) return [html('pre', {
+  ([body, overflow, closer, opener, delim, type = 'markdown', param]: string[], _, context) => {
+    if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
       'data-invalid-syntax': 'example',
-      'data-invalid-type': !closer ? 'fence' : 'argument',
-      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid argument',
-    }, `${opener}${body}${closer}`)];
+      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
+      'data-invalid-message':
+        !closer ? `Missing the closing delimiter "${delim}"` :
+        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
+        'Invalid argument',
+    }, `${opener}${body}${overflow || closer}`)];
     switch (type) {
       case 'markdown': {
         const annotations = html('ol', { class: 'annotations' });
@@ -52,6 +55,7 @@ export const example: ExtensionParser.ExampleParser = creator(100, block(validat
             class: 'invalid',
             translate: 'no',
             'data-invalid-syntax': 'example',
+            'data-invalid-type': 'type',
             'data-invalid-message': 'Invalid example type',
           }, `${opener}${body}${closer}`),
         ];

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

@@ -31,6 +31,8 @@ describe('Unit: parser/block/extension/fig', () => {
       assert.deepStrictEqual(inspect(parser('[$group-name]\n```\n~~~\n```')), [['<figure data-type="text" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><pre class="text">~~~</pre></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('[$group-name]\n$$\n\n$$')), [['<figure data-type="math" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><div class="math" translate="no">$$\n\n$$</div></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('[$group-name]\n$$\n\n$$\n')), [['<figure data-type="math" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><div class="math" translate="no">$$\n\n$$</div></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('[$group-name]\n~~~\n~~~')), [['<figure data-type="example" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><ol class="annotations"></ol><ol class="references"></ol></section></aside></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('[$group-name]\n~~~\n~~~\n')), [['<figure data-type="example" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><ol class="annotations"></ol><ol class="references"></ol></section></aside></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('[$group-name]\n~~~example/markdown\n~~~')), [['<figure data-type="example" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><ol class="annotations"></ol><ol class="references"></ol></section></aside></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('[$group-name]\n~~~example/markdown\n~~~\n')), [['<figure data-type="example" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><ol class="annotations"></ol><ol class="references"></ol></section></aside></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('[$group-name]\n~~~table\n~~~')), [['<figure data-type="table" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><table></table></div></figure>'], '']);

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

@@ -17,6 +17,7 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n\n\n\n~~~')), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n!https://host\n\n\n\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n !https://host\n~~~')), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n !https://host\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n~~~\n~~~')), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n!https://host\n~~~\n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n\ncaption\n~~~\n~~~')), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n!https://host\n\ncaption\n~~~\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n~~~~')), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n!https://host\n~~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~~figure [$group-name]\n!https://host\n~~~')), [['<pre class="invalid" translate="no">~~~~figure [$group-name]\n!https://host\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]a\nhttps://host\n~~~')), [['<pre class="invalid" translate="no">~~~figure [$group-name]a\nhttps://host\n~~~</pre>'], '']);
@@ -33,7 +34,7 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser('~~~figure [$figure-name]\n> \n\n~~~')), [['<figure data-type="quote" data-label="figure-name" data-group="figure" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><blockquote></blockquote></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$table-name]\n> \n\n~~~')), [['<figure data-type="quote" data-label="table-name" data-group="table" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><blockquote></blockquote></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser(`~~~figure [$group-name]\n0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
-      assert.deepStrictEqual(inspect(parser(`~~~figure [$group-name]\n~~~\n0${'\n'.repeat(301)}~~~\n~~~`), '>'), [['<pre class="invalid" translate="no">'], '\n~~~\n~~~']);
+      assert.deepStrictEqual(inspect(parser(`~~~figure [$group-name]\n~~~\n0${'\n'.repeat(301)}~~~\n~~~`), '>'), [['<pre class="invalid" translate="no">'], `${'\n'.repeat(300)}~~~\n~~~`]);
     });
 
     it('valid', () => {
@@ -52,6 +53,7 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n$$\n\n$$\n~~~')), [['<figure data-type="math" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><div class="math" translate="no">$$\n\n$$</div></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n$$\n~~~\n$$\n~~~')), [['<figure data-type="math" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><div class="math" translate="no">$$\n~~~\n$$</div></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n$$\n\n$$\n\ncaption\n~~~')), [['<figure data-type="math" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span>caption</figcaption><div><div class="math" translate="no">$$\n\n$$</div></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n~~~\n~~~\n\ncaption\n~~~')), [['<figure data-type="example" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span>caption</figcaption><div><aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><ol class="annotations"></ol><ol class="references"></ol></section></aside></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n~~~example/markdown\n~~~\n\ncaption\n~~~')), [['<figure data-type="example" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span>caption</figcaption><div><aside class="example" data-type="markdown"><pre translate="no"></pre><hr><section><ol class="annotations"></ol><ol class="references"></ol></section></aside></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n~~~table\n~~~\n\ncaption\n~~~')), [['<figure data-type="table" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span>caption</figcaption><div><table></table></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n> \n~~~\n\n~~~')), [['<figure data-type="quote" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><blockquote><pre><br>~~~</pre></blockquote></div></figure>'], '']);

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

@@ -48,7 +48,7 @@ export const segment: FigureParser.SegmentParser = block(match(
     closer),
   ([, fence]) => fence.length, [])));
 
-export const figure: FigureParser = block(fallback(rewrite(segment, fallback(fmap(
+export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:figure[^\S\n]+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
   sequence([
     line(sequence([label, str(/^(?=\s).*\n/)])),
@@ -82,30 +82,10 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fallback(fma
           defrag(caption))),
         html('div', [content]),
       ])
-  ]),
-  (source, context) => [[
-    html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      'data-invalid-syntax': 'figure',
-      ...
-      !seg_label(source.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context) && {
-        'data-invalid-type': 'label',
-        'data-invalid-message': 'Invalid label',
-      } ||
-      /^~+(?:figure[^\S\n]+)?(\[?\$\S+)[^\S\n]+\S/.test(source) && {
-        'data-invalid-type': 'argument',
-        'data-invalid-message': 'Invalid argument',
-      } ||
-      {
-        'data-invalid-type': 'content',
-        'data-invalid-message': 'Invalid content',
-      },
-    }, source),
-  ], ''])),
+  ])),
   fmap(
     fence(/^(~{3,})(?:figure|\[?\$\S*)(?!\S)[^\n]*(?:$|\n)/, 300),
-    ([body, closer, opener, delim]: string[], _, context) => [
+    ([body, overflow, closer, opener, delim]: string[], _, context) => [
       html('pre', {
         class: 'invalid',
         translate: 'no',
@@ -115,6 +95,10 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fallback(fma
           'data-invalid-type': 'fence',
           'data-invalid-message': `Missing the closing delimiter "${delim}"`,
         } ||
+        overflow && {
+          'data-invalid-type': 'fence',
+          'data-invalid-message': `Invalid trailing line after the closing delimiter "${delim}"`,
+        } ||
         !seg_label(opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context) && {
           'data-invalid-type': 'label',
           'data-invalid-message': 'Invalid label',
@@ -127,7 +111,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fallback(fma
           'data-invalid-type': 'content',
           'data-invalid-message': 'Invalid content',
         },
-      }, `${opener}${body}${closer}`),
+      }, `${opener}${body}${overflow || closer}`),
     ])));
 
 function attributes(label: string, param: string, content: HTMLElement, caption: readonly HTMLElement[]): Record<string, string | undefined> {

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

@@ -21,14 +21,17 @@ import MessageParser = ExtensionParser.MessageParser;
 export const message: MessageParser = block(validate('~~~', fmap(
   fence(/^(~{3,})message\/(\S+)([^\n]*)(?:$|\n)/, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, type, param]: string[], _, context) => {
-    if (!closer || param.trimStart()) return [html('pre', {
+  ([body, overflow, closer, opener, delim, type, param]: string[], _, context) => {
+    if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
       'data-invalid-syntax': 'message',
-      'data-invalid-type': !closer ? 'fence' : 'argument',
-      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid argument',
-    }, `${opener}${body}${closer}`)];
+      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
+      'data-invalid-message':
+        !closer ? `Missing the closing delimiter "${delim}"` :
+        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
+        'Invalid argument',
+    }, `${opener}${body}${overflow || closer}`)];
     switch (type) {
       case 'note':
       case 'caution':
@@ -39,6 +42,7 @@ export const message: MessageParser = block(validate('~~~', fmap(
           class: 'invalid',
           translate: 'no',
           'data-invalid-syntax': 'message',
+          'data-invalid-type': 'type',
           'data-invalid-message': 'Invalid message type',
         }, `${opener}${body}${closer}`)];
     }

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

@@ -12,12 +12,13 @@ export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(v
 
 export const placeholder: ExtensionParser.PlaceholderParser = block(validate('~~~', fmap(
   fence(opener, Infinity),
-  ([body, closer, opener, delim]) => [
+  ([body, overflow, closer, opener, delim]) => [
     html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-syntax': 'extension',
-      'data-invalid-type': !closer ? 'fence' : 'syntax',
-      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid extension name',
-    }, `${opener}${body}${closer}`),
+      'data-invalid-message':
+        !closer ? `Missing the closing delimiter "${delim}"` :
+        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
+        'Invalid argument',
+    }, `${opener}${body}${overflow || closer}`),
   ])));

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

@@ -26,14 +26,17 @@ export const segment_: TableParser.SegmentParser = block(validate('~~~',
 export const table: TableParser = block(validate('~~~', recover(fmap(
   fence(opener, 10000),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, param]: string[], _, context) => {
-    if (!closer || param.trimStart()) return [html('pre', {
+  ([body, overflow, closer, opener, delim, param]: string[], _, context) => {
+    if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
       'data-invalid-syntax': 'table',
-      'data-invalid-type': !closer ? 'fence' : 'argument',
-      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid argument',
-    }, `${opener}${body}${closer}`)];
+      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
+      'data-invalid-message':
+        !closer ? `Missing the closing delimiter "${delim}"` :
+        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
+        'Invalid argument',
+    }, `${opener}${body}${overflow || closer}`)];
     return eval(parser(body, context)) ?? [html('table')];
   }),
   (source, _, reason) =>

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

@@ -19,10 +19,12 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser('$$ $$\n$$')), undefined);
       assert.deepStrictEqual(inspect(parser('$$lang\n$$')), [['<pre class="invalid" translate="no">$$lang\n$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('$$ param\n$$')), [['<pre class="invalid" translate="no">$$ param\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('$$\n$$\n$$')), [['<pre class="invalid" translate="no">$$\n$$\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('$$\n$$$')), [['<pre class="invalid" translate="no">$$\n$$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('$$$\n$$')), [['<pre class="invalid" translate="no">$$$\n$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('$$$\n$$$')), [['<pre class="invalid" translate="no">$$$\n$$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser(' $$\n$$')), undefined);
-      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(101)}$$`), '>'), [['<pre class="invalid" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(301)}$$`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('basic', () => {
@@ -34,12 +36,10 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser('$$\n\\\n$$')), [['<div class="math" translate="no">$$\n\\\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$\n$$')), [['<div class="math" translate="no">$$\n$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$\n\n$$')), [['<div class="math" translate="no">$$\n$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser('$$\n$$\n$$')), [['<div class="math" translate="no">$$\n$$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$$\n\n$$')), [['<div class="math" translate="no">$$\n$$</div>'], '\n$$']);
       assert.deepStrictEqual(inspect(parser('$$\n$$$\n$$')), [['<div class="math" translate="no">$$\n$$$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$$$\n\n$$')), [['<div class="math" translate="no">$$\n$$$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser('$$\n$$\n$$')), [['<div class="math" translate="no">$$\n$$\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(100)}$$`), '>'), [['<div class="math" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(300)}$$`), '>'), [['<div class="math" translate="no">'], '']);
     });
 
   });

package/src/parser/block/mathblock.ts

@@ -6,23 +6,26 @@ import { html } from 'typed-dom/dom';
 const opener = /^(\${2,})(?!\$)([^\n]*)(?:$|\n)/;
 
 export const segment: MathBlockParser.SegmentParser = block(validate('$$',
-  clear(fence(opener, 100))));
+  clear(fence(opener, 300))));
 
 export const segment_: MathBlockParser.SegmentParser = block(validate('$$',
-  clear(fence(opener, 100, false))), false);
+  clear(fence(opener, 300, false))), false);
 
 export const mathblock: MathBlockParser = block(validate('$$', fmap(
-  fence(opener, 100),
+  fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, param]: string[], _, { caches: { math: cache = undefined } = {} }) => [
-    delim.length === 2 && closer && param.trimStart() === ''
+  ([body, overflow, closer, opener, delim, param]: string[], _, { caches: { math: cache = undefined } = {} }) => [
+    delim.length === 2 && closer && !overflow && param.trimStart() === ''
       ? cache?.get(`${delim}\n${body}${delim}`)?.cloneNode(true) as HTMLDivElement ||
         html('div', { class: 'math', translate: 'no' }, `${delim}\n${body}${delim}`)
       : html('pre', {
           class: 'invalid',
           translate: 'no',
           'data-invalid-syntax': 'mathblock',
-          'data-invalid-type': delim.length > 2 ? 'syntax' : !closer ? 'fence' : 'argument',
-          'data-invalid-message': delim.length > 2 ? 'Invalid syntax' : !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid argument',
-        }, `${opener}${body}${closer}`),
+          'data-invalid-type': delim.length > 2 ? 'syntax' : !closer || overflow ? 'fence' : 'argument',
+          'data-invalid-message': delim.length > 2 ? 'Invalid syntax' :
+             !closer ? `Missing the closing delimiter "${delim}"` :
+             overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
+             'Invalid argument',
+        }, `${opener}${body}${overflow || closer}`),
   ])));

package/src/parser/header.test.ts

@@ -21,6 +21,7 @@ describe('Unit: parser/header', () => {
       assert.deepStrictEqual(inspect(parser('---\n \n---')), undefined);
       assert.deepStrictEqual(inspect(parser('---\n-\n---')), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('----\na: b\n----')), [['<pre class="invalid" translate="no">----\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser(`---\n${'a: b\n'.repeat(101)}---`)), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
     });
 
     it('basic', () => {

package/src/parser/inline/bracket.test.ts

@@ -16,17 +16,33 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(1)')), [['(', '1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(10)')), [['(', '10', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(2000)')), [['(', '2000', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(1, 2)')), [['(', '1, 2', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(0-1)')), [['(', '0-1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(0)-1')), [['(', '0', ')'], '-1']);
       assert.deepStrictEqual(inspect(parser('(0.1)')), [['(', '0.1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(0.1.2)')), [['(', '0.1.2', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(1.1, 1.2-1.3, 1.4)')), [['(', '1.1, 1.2-1.3, 1.4', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(1 2)')), [['<span class="paren">(1 2)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('(1, 2)')), [['(', '1, 2', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(1a)')), [['(', '1a', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(a)')), [['(', 'a', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(a1)')), [['(', 'a1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(a-1)')), [['(', 'a-1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(a.1)')), [['(', 'a.1', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(a b)')), [['<span class="paren">(a b)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('(word)')), [['(', 'word', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(word word)')), [['<span class="paren">(word word)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('(word, word)')), [['(', 'word, word', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(A)')), [['(', 'A', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(Name)')), [['(', 'Name', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(Word Word)')), [['<span class="paren">(Word Word)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('(Name, Name)')), [['(', 'Name, Name', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(ABBR)')), [['(', 'ABBR', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(ABBR, ABBR)')), [['(', 'ABBR, ABBR', ')'], '']);
       assert.deepStrictEqual(inspect(parser('（１，２）')), [['（', '１，２', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（０－１）')), [['（', '０－１', '）'], '']);
-      assert.deepStrictEqual(inspect(parser('（０．１）（Ａ）')), [['（', '０．１', '）', '（', 'Ａ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('（０．１）')), [['（', '０．１', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('（ａ）')), [['（', 'ａ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('（Ａ）')), [['（', 'Ａ', '）'], '']);
     });
 
     it('[', () => {

package/src/parser/inline/bracket.ts

@@ -6,7 +6,7 @@ import { str } from '../source';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
-const index = /^(?:[0-9]+(?:(?:[.-]|, )[0-9]+)*|[A-Za-z])/;
+const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
 export const bracket: BracketParser = lazy(() => creator(union([
   surround(str('('), str(index), str(')')),

package/src/parser/inline/html.test.ts

@@ -93,22 +93,29 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<small __proto__>a</small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small constructor>a</small>')), [['<span class="invalid">&lt;small constructor&gt;a&lt;/small&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<small toString>a</small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small X>a</small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small x>a</small>')), [['<span class="invalid">&lt;small x&gt;a&lt;/small&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo>a</bdo>')), [['<span class="invalid">&lt;bdo&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo >a</bdo>')), [['<span class="invalid">&lt;bdo &gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo __proto__>a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo constructor>a</bdo>')), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo toString>a</bdo>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdo X>a</bdo>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdo x>a</bdo>')), [['<span class="invalid">&lt;bdo x&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir>a</bdo>')), [['<span class="invalid">&lt;bdo dir&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir=>a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir=rtl>a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir=">a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir="">a</bdo>')), [['<span class="invalid">&lt;bdo dir=""&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" dir="rtl">a</bdo>')), [['<span class="invalid">&lt;bdo dir="rtl" dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdo diR="rtl">a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" >a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl"  >a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo  dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr constructor>')), [['<wbr class="invalid">'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr X>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<wbr x>')), [['<wbr class="invalid">'], '']);
     });
 
   });