securemark 0.292.0 → 0.293.1

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

@@ -4,13 +4,21 @@ import { html } from 'typed-dom/dom';
 describe('Unit: parser/api/parse', () => {
   describe('parse', () => {
     it('huge input', () => {
-      assert.throws(() =>
-        parse(`${'\n'.repeat(10 * 1000 ** 2)}`));
+      assert.deepStrictEqual(
+        [...parse(`${'\n'.repeat(10 * 1000 ** 2)}`, { id: '' }).children].map(el => el.outerHTML),
+        [
+          '<h1 class="error">Error: Too large input over 1,000,000 bytes.</h1>',
+          `<pre class="error" translate="no">${'\n'.repeat(997)}...</pre>`,
+        ]);
     });
 
     it('huge segment', () => {
-      assert.throws(() =>
-        parse(`${'\n'.repeat(100 * 1000 + 1)}`));
+      assert.deepStrictEqual(
+        [...parse(`${'\n'.repeat(100 * 1000 + 1)}`, { id: '' }).children].map(el => el.outerHTML),
+        [
+          '<h1 class="error">Error: Too large segment over 100,000 bytes.</h1>',
+          `<pre class="error" translate="no">${'\n'.repeat(997)}...</pre>`,
+        ]);
     });
 
     it('result', () => {
@@ -74,7 +82,7 @@ describe('Unit: parser/api/parse', () => {
         ['<p>a<br>b</p>']);
       assert.deepStrictEqual(
         [...parse('a\n\\ \nb').children].map(el => el.outerHTML),
-        ['<p>a<br>\\ <br>b</p>']);
+        ['<p>a<br>\\<br>b</p>']);
       assert.deepStrictEqual(
         [...parse('a\n\\\nb').children].map(el => el.outerHTML),
         ['<p>a<br>\\<br>b</p>']);
@@ -353,9 +361,9 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack', function () {
       this.timeout(5000);
-      // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して5倍遅い程度。
+      // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して3倍遅い程度。
       // 5n = annotation/reference + link + url/math + ruby + text
-      const source = `${'.'.repeat(5 + 0)}((([[[[#$[${'.'.repeat(19997)}`;
+      const source = `${'.'.repeat(0 + 0)}((([[[[#$[${'.'.repeat(19998)}`;
       assert.deepStrictEqual(
         [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
           .map(el => el.tagName),
@@ -364,7 +372,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack error', function () {
       this.timeout(5000);
-      const source = `${'.'.repeat(5 + 1)}((([[[[#$[${'.'.repeat(19997)}`;
+      const source = `${'.'.repeat(0 + 1)}((([[[[#$[${'.'.repeat(19998)}`;
       assert.deepStrictEqual(
         [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
           .map(el => el.tagName),

package/src/parser/api/parse.ts

@@ -1,7 +1,7 @@
 import { ParserOptions } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { input, eval } from '../../combinator/data/parser';
-import { segment, validate, MAX_SEGMENT_SIZE } from '../segment';
+import { segment } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
 import { normalize } from './normalize';
@@ -16,7 +16,6 @@ interface Options extends ParserOptions {
 }
 
 export function parse(source: string, opts: Options = {}, context?: MarkdownParser.Options | MarkdownParser.Context): DocumentFragment {
-  if (!validate(source, MAX_SEGMENT_SIZE)) throw new Error(`Too large input over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes`);
   const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
   source = !context ? normalize(source) : source;
   context = {

package/src/parser/autolink.test.ts

@@ -15,15 +15,15 @@ describe('Unit: parser/autolink', () => {
       assert.deepStrictEqual(inspect(parser('#a'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('@a#b'), ctx), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['\\', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a#b'), ctx), [['a#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0a#b'), ctx), [['0a#b'], '']);
-      assert.deepStrictEqual(inspect(parser('あ#b'), ctx), [['あ#b'], '']);
-      assert.deepStrictEqual(inspect(parser('あい#b'), ctx), [['あ', 'い#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあ#b'), ctx), [['0aあ#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあい#b'), ctx), [['0a', 'あ', 'い#b'], '']);
+      assert.deepStrictEqual(inspect(parser('a#b'), ctx), [['a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0a#b'), ctx), [['0a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser('あ#b'), ctx), [['あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser('あい#b'), ctx), [['あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあ#b'), ctx), [['0a', 'あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあい#b'), ctx), [['0a', 'あい', '#b'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b'), ctx), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n#b'), ctx), [['a', '\\', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('0a>>b'), ctx), [['0a>>b'], '']);
+      assert.deepStrictEqual(inspect(parser('0a>>b'), ctx), [['0a', '>', '>b'], '']);
     });
 
   });

package/src/parser/autolink.ts

@@ -1,15 +1,13 @@
 import { MarkdownParser } from '../../markdown';
-import { union, some, convert, lazy } from '../combinator';
+import { union, some, lazy } from '../combinator';
 import { autolink as autolink_ } from './inline/autolink';
 import { linebreak, unescsource } from './source';
 
 export import AutolinkParser = MarkdownParser.AutolinkParser;
 
 export const autolink: AutolinkParser = lazy(() =>
-  convert(source => `\r${source}`,
   some(union([
     autolink_,
     linebreak,
     unescsource,
-  ])),
-  false));
+  ])));

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

@@ -76,7 +76,7 @@ describe('Unit: parser/block/blockquote', () => {
       assert.deepStrictEqual(inspect(parser('!> a\\\nb'), ctx), [['<blockquote><section><p>a<br>b</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> ++a\nb++'), ctx), [['<blockquote><section><p><ins>a<br>b</ins></p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> ++a\n> b++'), ctx), [['<blockquote><section><p><ins>a<br>b</ins></p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!>  a \n b  c '), ctx), [['<blockquote><section><p> a <br> b  c</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!>  a \n b  c '), ctx), [['<blockquote><section><p> a<br> b c</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> a'), ctx), [['<blockquote><blockquote><section><p>a</p><h2>References</h2><ol class="references"></ol></section></blockquote></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> a\n> b'), ctx), [['<blockquote><blockquote><section><p>a</p><h2>References</h2><ol class="references"></ol></section></blockquote><section><p>b</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> - a'), ctx), [['<blockquote><section><ul><li>a</li></ul><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);

package/src/parser/block/blockquote.ts

@@ -6,17 +6,17 @@ import { contentline } from '../source';
 import { parse } from '../api/parse';
 import { html, defrag } from 'typed-dom/dom';
 
-export const segment: BlockquoteParser.SegmentParser = block(validate(['!>', '>'], union([
-  validate(/^!?>+(?=[^\S\n]|\n[^\S\n]*\S)/, some(contentline)),
-])));
+export const segment: BlockquoteParser.SegmentParser = block(union([
+  validate(/!?>+(?=[^\S\n]|\n[^\S\n]*\S)/y, some(contentline)),
+]));
 
 export const blockquote: BlockquoteParser = lazy(() => block(rewrite(segment, union([
-  open(/^(?=>)/, source),
-  open(/^!(?=>)/, markdown),
+  open(/(?=>)/y, source),
+  open(/!(?=>)/y, markdown),
 ]))));
 
-const opener = /^(?=>>+(?:$|\s))/;
-const indent = block(open(opener, some(contentline, /^>(?:$|\s)/)), false);
+const opener = /(?=>>+(?:$|\s))/y;
+const indent = block(open(opener, some(contentline, />(?:$|\s)/y)), false);
 const unindent = (source: string) => source.replace(/(?<=^|\n)>(?:[^\S\n]|(?=>*(?:$|\s)))|\n$/g, '');
 
 const source: BlockquoteParser.SourceParser = lazy(() => fmap(

package/src/parser/block/codeblock.ts

@@ -1,20 +1,20 @@
 import { CodeBlockParser } from '../block';
 import { input, eval } from '../../combinator/data/parser';
-import { block, validate, fence, clear, fmap } from '../../combinator';
+import { block, fence, clear, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-const opener = /^(`{3,})(?!`)([^\n]*)(?:$|\n)/;
+const opener = /(`{3,})(?!`)([^\n]*)(?:$|\n)/y;
 const language = /^[0-9a-z]+(?:-[a-z][0-9a-z]*)*$/i;
 
-export const segment: CodeBlockParser.SegmentParser = block(validate('```',
-  clear(fence(opener, 300))));
+export const segment: CodeBlockParser.SegmentParser = block(
+  clear(fence(opener, 300)));
 
-export const segment_: CodeBlockParser.SegmentParser = block(validate('```',
-  clear(fence(opener, 300, false))), false);
+export const segment_: CodeBlockParser.SegmentParser = block(
+  clear(fence(opener, 300, false)), false);
 
-export const codeblock: CodeBlockParser = block(validate('```', fmap(
+export const codeblock: CodeBlockParser = block(fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
   ([body, overflow, closer, opener, delim, param]: string[], context) => {
@@ -74,4 +74,4 @@ export const codeblock: CodeBlockParser = block(validate('```', fmap(
           body.slice(0, -1) || undefined
         : defrag(eval(autolink(input(body.slice(0, -1), { ...context })), [])));
     return [el];
-  })));
+  }));

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

@@ -54,7 +54,7 @@ describe('Unit: parser/block/dlist', () => {
       assert.deepStrictEqual(inspect(parser('~ a\n: b\n\\\nc'), ctx), [['<dl><dt id="index::a">a</dt><dd>b<br>\\<br>c</dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a~ b'), ctx), [['<dl><dt id="index::a~_b">a~ b</dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a: b'), ctx), [['<dl><dt id="index::a:_b">a: b</dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser('~ a \n: b \nc '), ctx), [['<dl><dt id="index::a">a</dt><dd>b <br>c</dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser('~ a \n: b\nc '), ctx), [['<dl><dt id="index::a">a</dt><dd>b<br>c</dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a \n: b\n c '), ctx), [['<dl><dt id="index::a">a</dt><dd>b<br> c</dd></dl>'], '']);
     });
 

package/src/parser/block/dlist.ts

@@ -3,13 +3,12 @@ import { State } from '../context';
 import { union, inits, some, state, block, line, validate, rewrite, open, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { anyline } from '../source';
-import { lineable } from '../util';
 import { visualize, trimBlank, trimBlankEnd } from '../visibility';
 import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 export const dlist: DListParser = lazy(() => block(fmap(validate(
-  /^~[^\S\n]+(?=\S)/,
+  /~[^\S\n]+(?=\S)/y,
   some(inits([
     state(State.annotation | State.reference | State.index | State.label | State.link,
     some(term)),
@@ -18,16 +17,16 @@ export const dlist: DListParser = lazy(() => block(fmap(validate(
   es => [html('dl', fillTrailingDescription(es))])));
 
 const term: DListParser.TermParser = line(indexee(fmap(open(
-  /^~[^\S\n]+(?=\S)/,
+  /~[^\S\n]+(?=\S)/y,
   visualize(trimBlank(some(union([indexer, inline])))),
   true),
   ns => [html('dt', { 'data-index': dataindex(ns) }, defrag(ns))])));
 
 const desc: DListParser.DescriptionParser = block(fmap(open(
-  /^:[^\S\n]+(?=\S)|/,
+  /:[^\S\n]+(?=\S)|/y,
   rewrite(
-    some(anyline, /^[~:][^\S\n]+\S/),
-    visualize(trimBlankEnd(lineable(some(union([inline])))))),
+    some(anyline, /[~:][^\S\n]+\S/y),
+    visualize(trimBlankEnd(some(union([inline]))))),
   true),
   ns => [html('dd', defrag(ns))]),
   false);

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

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

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

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

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

@@ -8,13 +8,13 @@ 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 { media, shortmedia } from '../../inline';
+import { media, lineshortmedia } from '../../inline';
 
 import FigParser = ExtensionParser.FigParser;
 
-export const segment: FigParser.SegmentParser = block(validate(['[$', '$'],
+export const segment: FigParser.SegmentParser = block(validate(/\[?\$/y,
   sequence([
-    line(close(seg_label, /^(?=\s).*\n/)),
+    line(close(seg_label, /(?=\s).*\n/y)),
     union([
       seg_code,
       seg_math,
@@ -39,10 +39,10 @@ export const fig: FigParser = block(rewrite(segment, verify(convert(
   ([el]) => el.tagName === 'FIGURE')));
 
 const parser = sequence([
-  line(close(seg_label, /^(?=\s).*\n/)),
+  line(close(seg_label, /(?=\s).*\n/y)),
   line(union([
     media,
-    shortmedia,
+    lineshortmedia,
   ])),
   some(contentline),
 ]);

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

@@ -4,7 +4,7 @@ import { label } from '../../inline/extension/label';
 import { html } from 'typed-dom/dom';
 
 export const figbase: ExtensionParser.FigbaseParser = block(fmap(
-  validate(/^\[?\$-(?:[0-9]+\.)*0\]?[^\S\n]*(?!\S|\n[^\S\n]*\S)/,
+  validate(/\[?\$-(?:[0-9]+\.)*0\]?[^\S\n]*(?!\S|\n[^\S\n]*\S)/y,
   line(union([label]))),
   ([el]) => {
     const label = el.getAttribute('data-label')!;

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

@@ -13,7 +13,6 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser('~~~figure $group-name]\n!https://host\n~~~'), ctx), [['<pre class="invalid" translate="no">~~~figure $group-name]\n!https://host\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name\n!https://host\n~~~'), ctx), [['<pre class="invalid" translate="no">~~~figure [$group-name\n!https://host\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\nhttps://host\n~~~'), ctx), [['<pre class="invalid" translate="no">~~~figure [$group-name]\nhttps://host\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\\\n~~~'), ctx), [['<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~~~'), ctx), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n!https://host\n\\\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\na\n~~~'), ctx), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n!https://host\na\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n\n\n\n~~~'), ctx), [['<pre class="invalid" translate="no">~~~figure [$group-name]\n!https://host\n\n\n\n~~~</pre>'], '']);
@@ -60,6 +59,7 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n~~~table\n~~~\n\ncaption\n~~~'), ctx), [['<figure data-type="table" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span><span class="figtext">caption</span></figcaption><div><table></table></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n> \n~~~\n\n~~~'), ctx), [['<figure data-type="quote" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span><span class="figtext"></span></figcaption><div><blockquote><pre><br>~~~</pre></blockquote></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n> \n~~~\n\ncaption\n~~~'), ctx), [['<figure data-type="quote" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span><span class="figtext">caption</span></figcaption><div><blockquote><pre><br>~~~</pre></blockquote></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\\\n~~~'), ctx), [['<figure data-type="media" data-label="group-name" data-group="group"><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('~~~figure [$group-name]\n![]{https://host}\n~~~'), ctx), [['<figure data-type="media" data-label="group-name" data-group="group"><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('~~~~figure [$group-name]\n!https://host\n~~~~'), ctx), [['<figure data-type="media" data-label="group-name" data-group="group"><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('~~~figure $group-name\n!https://host\n~~~'), ctx), [['<figure data-type="media" data-label="group-name" data-group="group"><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>'], '']);

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

@@ -12,7 +12,7 @@ import { example } from './example';
 import { table, segment_ as seg_table } from './table';
 import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
-import { inline, media, shortmedia } from '../../inline';
+import { inline, media, lineshortmedia } from '../../inline';
 import { visualize, trimBlank } from '../../visibility';
 import { invalid } from '../../util';
 import { memoize } from 'spica/memoize';
@@ -21,9 +21,9 @@ import { html, defrag } from 'typed-dom/dom';
 import FigureParser = ExtensionParser.FigureParser;
 
 export const segment: FigureParser.SegmentParser = block(match(
-  /^(~{3,})(?:figure[^\S\n])?(?=\[?\$)/,
+  /(~{3,})(?:figure[^\S\n])?(?=\[?\$)/y,
   memoize(
-  ([, fence], closer = new RegExp(String.raw`^${fence}[^\S\n]*(?:$|\n)`)) => close(
+  ([, fence], closer = new RegExp(String.raw`${fence}[^\S\n]*(?:$|\n)`, 'y')) => close(
     sequence([
       contentline,
       inits([
@@ -49,7 +49,7 @@ export const segment: FigureParser.SegmentParser = block(match(
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
   sequence([
-    line(sequence([label, str(/^(?=\s).*\n/)])),
+    line(sequence([label, str(/(?=\s).*\n/y)])),
     inits([
       block(union([
         ulist,
@@ -62,7 +62,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
         blockquote,
         placeholder,
         line(media),
-        line(shortmedia),
+        line(lineshortmedia),
       ])),
       emptyline,
       block(visualize(trimBlank(some(inline)))),
@@ -80,7 +80,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
       ])
   ])),
   fmap(
-    fence(/^(~{3,})(?:figure|\[?\$\S*)(?!\S)[^\n]*(?:$|\n)/, 300),
+    fence(/(~{3,})(?:figure|\[?\$\S*)(?!\S)[^\n]*(?:$|\n)/y, 300),
     ([body, overflow, closer, opener, delim]: string[], context) => {
       const violation =
         !closer && [

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

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../block';
 import { input, eval } from '../../../combinator/data/parser';
-import { union, block, validate, fence, fmap } from '../../../combinator';
+import { union, block, fence, fmap } from '../../../combinator';
 import { segment } from '../../segment';
 import { emptyline } from '../../source';
 import { ulist } from '../ulist';
@@ -19,8 +19,8 @@ import { html } from 'typed-dom/dom';
 
 import MessageParser = ExtensionParser.MessageParser;
 
-export const message: MessageParser = block(validate('~~~', fmap(
-  fence(/^(~{3,})message\/(\S+)([^\n]*)(?:$|\n)/, 300),
+export const message: MessageParser = block(fmap(
+  fence(/(~{3,})message\/(\S+)([^\n]*)(?:$|\n)/y, 300),
   // Bug: Type mismatch between outer and inner.
   ([body, overflow, closer, opener, delim, type, param]: string[], context) => {
     if (!closer || overflow || param.trimStart()) return [html('pre', {
@@ -50,7 +50,7 @@ export const message: MessageParser = block(validate('~~~', fmap(
         [html('h1', title(type))],
         [...segment(body)].reduce((acc, seg) => push(acc, eval(content(input(seg, { ...context })), [])), []))),
     ];
-  })));
+  }));
 
 function title(type: string): string {
   switch (type) {

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

@@ -1,17 +1,17 @@
 import { ExtensionParser } from '../../block';
-import { block, validate, fence, clear, fmap } from '../../../combinator';
+import { block, fence, clear, fmap } from '../../../combinator';
 import { invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
-const opener = /^(~{3,})(?!~)[^\n]*(?:$|\n)/;
+const opener = /(~{3,})(?!~)[^\n]*(?:$|\n)/y;
 
-export const segment: ExtensionParser.PlaceholderParser.SegmentParser = block(validate('~~~',
-  clear(fence(opener, 300))));
+export const segment: ExtensionParser.PlaceholderParser.SegmentParser = block(
+  clear(fence(opener, 300)));
 
-export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(validate('~~~',
-  clear(fence(opener, 300, false))), false);
+export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(
+  clear(fence(opener, 300, false)), false);
 
-export const placeholder: ExtensionParser.PlaceholderParser = block(validate('~~~', fmap(
+export const placeholder: ExtensionParser.PlaceholderParser = block(fmap(
   fence(opener, Infinity),
   ([body, overflow, closer, opener, delim]) => [
     html('pre', {
@@ -24,4 +24,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = block(validate('~~
           overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
             'Invalid argument'),
     }, `${opener}${body}${overflow || closer}`),
-  ])));
+  ]));

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

@@ -147,7 +147,7 @@ describe('Unit: parser/block/extension/table', () => {
         [[html('table', [
           html('thead'),
           html('tbody', [
-            html('tr', [html('td', ['\\ ', html('br'), '\\ ', html('br'), '0'])]),
+            html('tr', [html('td', ['\\', html('br'), '\\', html('br'), '0'])]),
           ]),
           html('tfoot'),
         ]).outerHTML], '']);

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

@@ -2,9 +2,9 @@ import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
 import { Node, eval, input } from '../../../combinator/data/parser';
 import { union, subsequence, inits, some, block, line, validate, fence, rewrite, clear, surround, open, convert, dup, lazy, fmap } from '../../../combinator';
-import { inline, medialink, media, shortmedia } from '../../inline';
+import { inline, medialink, media, lineshortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
-import { lineable, invalid } from '../../util';
+import { invalid } from '../../util';
 import { visualize, trimBlank, trimBlankEnd } from '../../visibility';
 import { unshift, splice } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -14,15 +14,15 @@ import RowParser = TableParser.RowParser;
 import AlignParser = TableParser.AlignParser;
 import CellParser = TableParser.CellParser;
 
-const opener = /^(~{3,})table(?:\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/;
+const opener = /(~{3,})table(?:\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/y;
 
-export const segment: TableParser.SegmentParser = block(validate('~~~',
-  clear(fence(opener, 10000))));
+export const segment: TableParser.SegmentParser = block(
+  clear(fence(opener, 10000)));
 
-export const segment_: TableParser.SegmentParser = block(validate('~~~',
-  clear(fence(opener, 10000, false))), false);
+export const segment_: TableParser.SegmentParser = block(
+  clear(fence(opener, 10000, false)), false);
 
-export const table: TableParser = block(validate('~~~', fmap(
+export const table: TableParser = block(fmap(
   fence(opener, 10000),
   // Bug: Type mismatch between outer and inner.
   ([body, overflow, closer, opener, delim, type, param]: string[], context) => {
@@ -48,7 +48,7 @@ export const table: TableParser = block(validate('~~~', fmap(
           ...invalid('table', 'argument', 'Invalid table type'),
         }, `${opener}${body}${closer}`)];
     }
-  })));
+  }));
 
 const parser: TableParser = lazy(() => block(fmap(
   some(union([row])),
@@ -68,43 +68,53 @@ const row: RowParser = lazy(() => dup(fmap(
   ]),
   ns => !isArray(ns[0]) ? unshift([[[]]], ns) : ns)));
 
-const alignment = /^[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)/;
+const alignment = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)/y;
 
 const align: AlignParser = line(fmap(
   union([str(alignment)]),
   ([s]) => s.split('/').map(s => s.split(''))));
 
-const delimiter = /^[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)|^[#:](?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=\s)/;
+const delimiter = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)|[#:](?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=\s)/y;
 
 const head: CellParser.HeadParser = block(fmap(open(
-  str(/^#(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=\s)/),
+  str(/#(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=\s)/y),
   rewrite(
     inits([
       anyline,
       some(contentline, delimiter),
     ]),
     union([
-      block(surround(/^[^\n]/, medialink, /^\s*$/)),
-      block(surround(/^[^\n]/, media, /^\s*$/)),
-      block(surround(/^[^\n]/, shortmedia, /^\s*$/)),
-      open(/^(?:\s*\n|\s)/, visualize(trimBlank(some(inline))), true),
+      block(surround(
+        /\s/y,
+        union([
+          medialink,
+          media,
+          lineshortmedia,
+        ]),
+        /\s*$/y)),
+      open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlank(some(inline))), true),
     ])),
   true),
   ns => [html('th', attributes(ns.shift()! as string), defrag(ns))]),
   false);
 
 const data: CellParser.DataParser = block(fmap(open(
-  str(/^:(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=\s)/),
+  str(/:(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=\s)/y),
   rewrite(
     inits([
       anyline,
       some(contentline, delimiter),
     ]),
     union([
-      block(surround(/^[^\n]/, medialink, /^\s*$/)),
-      block(surround(/^[^\n]/, media, /^\s*$/)),
-      block(surround(/^[^\n]/, shortmedia, /^\s*$/)),
-      open(/^(?:\s*\n|\s)/, visualize(trimBlankEnd(lineable(some(inline)))), true),
+      block(surround(
+        /\s/y,
+        union([
+          medialink,
+          media,
+          lineshortmedia,
+        ]),
+        /\s*$/y)),
+      open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlankEnd(some(inline))), true),
     ])),
   true),
   ns => [html('td', attributes(ns.shift()! as string), defrag(ns))]),
@@ -114,7 +124,7 @@ const dataline: CellParser.DatalineParser = line(
   rewrite(
     contentline,
     union([
-      validate(/^!+\s/, convert(source => `:${source}`, data, false)),
+      validate(/!+\s/y, convert(source => `:${source}`, data, false)),
       convert(source => `: ${source}`, data, false),
     ])));
 

package/src/parser/block/extension.ts

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../block';
-import { union, validate } from '../../combinator';
+import { union } from '../../combinator';
 import { figbase } from './extension/figbase';
 import { fig, segment as seg_fig } from './extension/fig';
 import { figure, segment as seg_figure } from './extension/figure';
@@ -9,12 +9,12 @@ import { aside } from './extension/aside';
 import { example } from './extension/example';
 import { placeholder, segment as seg_placeholder } from './extension/placeholder';
 
-export const segment: ExtensionParser.SegmentParser = validate(['~~~', '[$', '$'], validate(/^~{3,}|^\[?\$[A-Za-z-]\S+[^\S\n]*(?:$|\n)/, union([
+export const segment: ExtensionParser.SegmentParser = union([
   seg_fig,
   seg_figure,
   seg_table,
   seg_placeholder,
-])));
+]);
 
 export const extension: ExtensionParser = union([
   figbase,

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

@@ -35,7 +35,7 @@ describe('Unit: parser/block/heading', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('# a'), ctx), [['<h1 id="index::a">a</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a '), ctx), [['<h1 id="index::a">a</h1>'], '']);
-      assert.deepStrictEqual(inspect(parser('# a b  c \n'), ctx), [['<h1 id="index::a_b__c">a b  c</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser('# a b  c \n'), ctx), [['<h1 id="index::a_b_c">a b c</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a\n'), ctx), [['<h1 id="index::a">a</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# *a*`b`${c}$'), ctx), [['<h1 id="index::a`b`${c}$"><em>a</em><code data-src="`b`">b</code><span class="math" translate="no" data-src="${c}$">${c}$</span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a\\'), ctx), [['<h1 id="index::a">a</h1>'], '']);