securemark 0.240.2 → 0.243.0

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

@@ -1,22 +1,23 @@
 import { undefined } from 'spica/global';
 import { Parser, eval, exec } from '../../data/parser';
 import { some } from '../../data/parser/some';
+import { block } from '../constraint/block';
 import { line } from '../constraint/line';
 import { bind } from '../monad/bind';
 import { match } from './match';
 import { open } from './surround';
-import { reduce } from 'spica/memoize';
+import { memoize } from 'spica/memoize';
 import { join } from 'spica/array';
 
-export function indent<P extends Parser<unknown>>(parser: P): P;
-export function indent<T>(parser: Parser<T>): Parser<T> {
+export function indent<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
+export function indent<T>(parser: Parser<T>, separation = false): Parser<T> {
   assert(parser);
-  return bind(match(
+  return bind(block(match(
     /^(?=(([ \t])\2*))/,
-    reduce<string[], Parser<string>, string>(
+    memoize(
     ([, indent]) =>
       some(line(open(indent, source => [[unline(source)], '']))),
-    ([, indent]) => indent)),
+    ([, indent]) => indent.length * 2 + +(indent[0] === ' '), [])), separation),
     (nodes, rest, context) => {
       const result = parser(join(nodes, '\n'), context);
       return result && exec(result) === ''

package/src/debug.test.ts

@@ -1,5 +1,5 @@
 import { Result, eval, exec } from './combinator/data/parser';
-import { html, define } from 'typed-dom';
+import { html, define } from 'typed-dom/dom';
 
 export function inspect(result: Result<HTMLElement | string>, until: number | string = Infinity): Result<string> {
   return result && [

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

@@ -1,6 +1,6 @@
 import { ParserSettings, Progress } from '../../..';
 import { bind } from './bind';
-import { frag, html } from 'typed-dom';
+import { frag, html } from 'typed-dom/dom';
 
 describe('Unit: parser/api/bind', () => {
   describe('bind', () => {

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

@@ -1,5 +1,5 @@
 import { parse } from './parse';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 describe('Unit: parser/api/parse', () => {
   describe('parse', () => {

package/src/parser/api/parse.ts

@@ -9,7 +9,7 @@ import { normalize } from './normalize';
 import { headers } from './header';
 import { figure } from '../processor/figure';
 import { footnote } from '../processor/footnote';
-import { frag } from 'typed-dom';
+import { frag } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 
 interface Options extends ParserOptions {

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

@@ -76,10 +76,10 @@ describe('Unit: parser/block/blockquote', () => {
       assert.deepStrictEqual(inspect(parser('!>> a')), [['<blockquote><blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!>> a\n> b')), [['<blockquote><blockquote><section><p>a</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote><section><p>b</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> - a')), [['<blockquote><section><ul><li>a</li></ul><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> ```\na\n```')), [['<blockquote><section><pre class="text" translate="no">a</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> ```\n> a\n```')), [['<blockquote><section><pre class="text" translate="no">a</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> ```\n> a\n> ```')), [['<blockquote><section><pre class="text" translate="no">a</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> ```\n> a\n> \n> b\n> ```')), [['<blockquote><section><pre class="text" translate="no">a<br><br>b</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> ```\na\n```')), [['<blockquote><section><pre class="text">a</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> ```\n> a\n```')), [['<blockquote><section><pre class="text">a</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> ```\n> a\n> ```')), [['<blockquote><section><pre class="text">a</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('!> ```\n> a\n> \n> b\n> ```')), [['<blockquote><section><pre class="text">a<br><br>b</pre><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> a\n>\n> b')), [['<blockquote><section><p>a</p><p>b</p><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> > a')), [['<blockquote><section><blockquote><pre>a</pre></blockquote><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);
       assert.deepStrictEqual(inspect(parser('!> > a\n> b')), [['<blockquote><section><blockquote><pre>a<br>b</pre></blockquote><ol class="annotations"></ol><ol class="references"></ol></section></blockquote>'], '']);

package/src/parser/block/blockquote.ts

@@ -3,7 +3,7 @@ import { union, some, block, validate, rewrite, creator, open, convert, lazy, fm
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { parse } from '../api/parse';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const segment: BlockquoteParser.SegmentParser = block(validate(['!>', '>'], union([
   validate(/^!?>+(?=[^\S\n]|\n[^\S\n]*\S)/, some(contentline)),
@@ -15,14 +15,8 @@ export const blockquote: BlockquoteParser = lazy(() => block(rewrite(segment, un
 ]))));
 
 const opener = /^(?=>>+(?:$|\s))/;
-
 const indent = block(open(opener, some(contentline, /^>(?:$|\s)/)), false);
-
-function unindent(source: string): string {
-  return source
-    .replace(/\n$/, '')
-    .replace(/^>(?:$|\s|(?=>+(?:$|\s)))/mg, '');
-}
+const unindent = (source: string) => source.replace(/(^|\n)>(?:[^\S\n]|(?=>*(?:$|\s)))|\n$/g, '$1');
 
 const source: BlockquoteParser.SourceParser = lazy(() => fmap(
   some(creator(union([

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

@@ -24,24 +24,24 @@ describe('Unit: parser/block/codeblock', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('```\n```')), [['<pre class="text" translate="no"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n\n```')), [['<pre class="text" translate="no"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\na\n```')), [['<pre class="text" translate="no">a</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\na\nb\n```')), [['<pre class="text" translate="no">a<br>b</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n\\\n```')), [['<pre class="text" translate="no">\\</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n`\n```')), [['<pre class="text" translate="no">`</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n```\n```')), [['<pre class="text" translate="no">```</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n```\n\n```')), [['<pre class="text" translate="no"></pre>'], '\n```']);
-      assert.deepStrictEqual(inspect(parser('```\n````\n```')), [['<pre class="text" translate="no">````</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n````\n\n```')), [['<pre class="text" translate="no">````<br></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('````\n```\n````')), [['<pre class="text" translate="no">```</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('````\n```\n\n````')), [['<pre class="text" translate="no">```<br></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n\n```\n')), [['<pre class="text" translate="no"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\nhttp://host\n```')), [['<pre class="text" translate="no"><a href="http://host" target="_blank">http://host</a></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n!http://host\n```')), [['<pre class="text" translate="no">!<a href="http://host" target="_blank">http://host</a></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n#a\n```')), [['<pre class="text" translate="no"><a href="/hashtags/a" class="hashtag">#a</a></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```\n@a#b\n```')), [['<pre class="text" translate="no"><a href="/@a?ch=b" class="channel">@a#b</a></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser(`\`\`\`\n0${'\n'.repeat(300)}\`\`\``), '>'), [['<pre class="text" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser('```\n```')), [['<pre class="text"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```\n\n```')), [['<pre class="text"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```\na\n```')), [['<pre class="text">a</pre>'], '']);
+      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>'], '']);
+      assert.deepStrictEqual(inspect(parser('````\n```\n````')), [['<pre class="text">```</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('````\n```\n\n````')), [['<pre class="text">```<br></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```\n\n```\n')), [['<pre class="text"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```\nhttp://host\n```')), [['<pre class="text"><a href="http://host" target="_blank">http://host</a></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```\n!http://host\n```')), [['<pre class="text">!<a href="http://host" target="_blank">http://host</a></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```\n#a\n```')), [['<pre class="text"><a href="/hashtags/a" class="hashtag">#a</a></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```\n@a#b\n```')), [['<pre class="text"><a href="/@a?ch=b" class="channel">@a#b</a></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser(`\`\`\`\n0${'\n'.repeat(300)}\`\`\``), '>'), [['<pre class="text">'], '']);
     });
 
     it('attribute', () => {
@@ -50,21 +50,21 @@ describe('Unit: parser/block/codeblock', () => {
       assert.deepStrictEqual(inspect(parser('```A\n```')), [['<pre class="code language-a" translate="no" data-lang="a"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```a-b\n```')), [['<pre class="code language-a-b" translate="no" data-lang="a-b"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```a-b0\n```')), [['<pre class="code language-a-b0" translate="no" data-lang="a-b0"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```a--b\n```')), [['<pre class="text" translate="no" data-path="a--b"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('``` b\n```')), [['<pre class="text" translate="no" data-path="b"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```a--b\n```')), [['<pre class="text" data-path="a--b"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('``` b\n```')), [['<pre class="text" data-path="b"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('``` b c\n```')), [['<pre class="invalid" translate="no">``` b c\n```</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('``` b\\ c\n```')), [['<pre class="text" translate="no" data-path="b\\ c"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('``` b\\ c\n```')), [['<pre class="text" data-path="b\\ c"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('``` b.c\n```')), [['<pre class="code language-c" translate="no" data-lang="c" data-path="b.c"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('``` .b\n```')), [['<pre class="text" translate="no" data-path=".b"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```  b \n```')), [['<pre class="text" translate="no" data-path="b"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('``` ~/.b\n```')), [['<pre class="text" translate="no" data-path="~/.b"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('``` .b\n```')), [['<pre class="text" data-path=".b"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```  b \n```')), [['<pre class="text" data-path="b"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('``` ~/.b\n```')), [['<pre class="text" data-path="~/.b"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('``` ~/b.c\n```')), [['<pre class="code language-c" translate="no" data-lang="c" data-path="~/b.c"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('```.b\n```')), [['<pre class="text" translate="no" data-path=".b"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('```.b\n```')), [['<pre class="text" data-path=".b"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```b.c\n```')), [['<pre class="code language-c" translate="no" data-lang="c" data-path="b.c"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```a b.c\n```')), [['<pre class="code language-a" translate="no" data-lang="a" data-path="b.c"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('```a 1\n```')), [['<pre class="code language-a" translate="no" data-lang="a" data-line="1"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('``` 1\n```')), [['<pre class="text" translate="no" data-line="1"></pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('``` 1,2-3\n```')), [['<pre class="text" translate="no" data-line="1,2-3"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('``` 1\n```')), [['<pre class="text" data-line="1"></pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('``` 1,2-3\n```')), [['<pre class="text" data-line="1,2-3"></pre>'], '']);
       assert.deepStrictEqual(inspect(parser('``` 1 b.c\n```')), [['<pre class="code language-c" translate="no" data-lang="c" data-line="1" data-path="b.c"></pre>'], '']);
     });
 

package/src/parser/block/codeblock.ts

@@ -3,7 +3,7 @@ import { CodeBlockParser } from '../block';
 import { eval } from '../../combinator/data/parser';
 import { some, block, validate, fence, clear, fmap } from '../../combinator';
 import { autolink } from '../autolink';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 const opener = /^(`{3,})(?!`)([^\n]*)(?:$|\n)/;
 const language = /^[0-9a-z]+(?:-[a-z][0-9a-z]*)*$/i;
@@ -59,7 +59,7 @@ export const codeblock: CodeBlockParser = block(validate('```', fmap(
     const el = html('pre',
       {
         class: params.lang ? `code language-${params.lang}` : 'text',
-        translate: 'no',
+        translate: params.lang ? 'no' : undefined,
         'data-lang': params.lang || undefined,
         'data-line': params.line || undefined,
         'data-path': params.path || undefined,

package/src/parser/block/dlist.ts

@@ -4,7 +4,7 @@ import { inline, indexee, indexer } from '../inline';
 import { anyline } from '../source';
 import { localize } from '../locale';
 import { visualize } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { push } from 'spica/array';
 
 export const dlist: DListParser = lazy(() => block(localize(fmap(validate(

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

@@ -2,7 +2,7 @@ import { ExtensionParser } from '../../block';
 import { block, validate, fence, creator, fmap } from '../../../combinator';
 import { identity, text } from '../../inline/extension/indexee';
 import { parse } from '../../api/parse';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 export const aside: ExtensionParser.AsideParser = creator(100, block(validate('~~~', fmap(
   fence(/^(~{3,})aside(?!\S)([^\n]*)(?:$|\n)/, 300),

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

@@ -3,7 +3,7 @@ import { eval } from '../../../combinator/data/parser';
 import { block, validate, fence, creator, fmap } from '../../../combinator';
 import { parse } from '../../api/parse';
 import { mathblock } from '../mathblock';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 const opener = /^(~{3,})(?:example\/(\S+)|(?!\S))([^\n]*)(?:$|\n)/;
 

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

@@ -26,9 +26,9 @@ describe('Unit: parser/block/extension/fig', () => {
       assert.deepStrictEqual(inspect(parser('[$group-name]\n!https://host\n')), [['<figure data-type="media" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt=""></a></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('[$group-name]\n|\n|-\n|')), [['<figure data-type="table" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><table><thead><tr></tr></thead><tbody><tr></tr></tbody></table></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('[$group-name]\n|\n|-\n|\n')), [['<figure data-type="table" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><table><thead><tr></tr></thead><tbody><tr></tr></tbody></table></div></figure>'], '']);
-      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" translate="no"></pre></div></figure>'], '']);
-      assert.deepStrictEqual(inspect(parser('[$group-name]\n```\n\n```\n')), [['<figure data-type="text" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><pre class="text" translate="no"></pre></div></figure>'], '']);
-      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" translate="no">~~~</pre></div></figure>'], '']);
+      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```\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="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~~~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>'], '']);

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

@@ -1,12 +1,12 @@
 import { ExtensionParser } from '../../block';
-import { union, sequence, some, block, line, validate, rewrite, close, convert } from '../../../combinator';
+import { union, sequence, some, block, line, validate, verify, rewrite, close, convert } 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_blockquote } from '../blockquote';
 import { segment as seg_table } from './table';
+import { segment as seg_blockquote } from '../blockquote';
 import { segment as seg_placeholder } from './placeholder';
 
 import FigParser = ExtensionParser.FigParser;
@@ -17,17 +17,18 @@ export const segment: FigParser.SegmentParser = block(validate(['[$', '$'],
     union([
       seg_code,
       seg_math,
-      seg_blockquote,
       seg_table,
+      seg_blockquote,
       seg_placeholder,
       some(contentline),
     ]),
   ])));
 
-export const fig: FigParser = block(rewrite(segment, convert(
+export const fig: FigParser = block(rewrite(segment, verify(convert(
   source => {
-    const fence = (/^[^\n]*\n!?>+\s/.test(source) && source.match(/^~{3,}(?=\s*$)/mg) || [])
+    const fence = (/^[^\n]*\n!?>+\s/.test(source) && source.match(/^~{3,}(?=[^\S\n]*$)/mg) || [])
       .reduce((max, fence) => fence > max ? fence : max, '~~') + '~';
     return `${fence}figure ${source}\n\n${fence}`;
   },
-  union([figure]))));
+  union([figure])),
+  ([el]) => el.className !== 'invalid' || el.getAttribute('data-invalid-type') !== 'content')));

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

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

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

@@ -10,19 +10,19 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser('~~~figure\n!https://host\n~~~')), undefined);
       assert.deepStrictEqual(inspect(parser('~~~figure $group-name]\n!https://host\n~~~')), [['<figure data-type="media" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt=""></a></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name\n!https://host\n~~~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\nhttps://host\n~~~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\\\n~~~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n\\\n~~~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\na\n~~~')), undefined);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\nhttps://host\n~~~')), [['<figure data-type="invalid" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><br></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\\\n~~~')), [['<figure data-type="invalid" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><br></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n\\\n~~~')), [['<figure data-type="invalid" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><br></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\na\n~~~')), [['<figure data-type="invalid" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><br></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n\n\n\n~~~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n !https://host\n~~~')), undefined);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n !https://host\n~~~')), [['<figure data-type="invalid" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><br></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n\n!https://host\n~~~')), undefined);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n~~~\n~~~')), undefined);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n!https://host\n~~~~')), undefined);
       assert.deepStrictEqual(inspect(parser('~~~~figure [$group-name]\n!https://host\n~~~')), undefined);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]a\nhttps://host\n~~~')), undefined);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]a\nhttps://host\n~~~')), [['<figure data-type="invalid" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><br></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]a\n!https://host\n~~~')), [['<figure data-type="media" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt=""></a></div></figure>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name] a\nhttps://host\n~~~')), undefined);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name] a\nhttps://host\n~~~')), [['<figure data-type="invalid" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><br></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name] a\n!https://host\n~~~')), [['<figure data-type="media" data-label="group-name" data-group="group" class="invalid"><figcaption><span class="figindex"></span></figcaption><div><a href="https://host" target="_blank"><img class="media" data-src="https://host" alt=""></a></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure a[$group-name]\n!https://host\n~~~')), undefined);
       assert.deepStrictEqual(inspect(parser('~~~figure a [$group-name]\n!https://host\n~~~')), undefined);
@@ -46,9 +46,9 @@ describe('Unit: parser/block/extension/figure', () => {
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n- a\n~~~')), [['<figure data-type="list" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><ul><li>a</li></ul></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n1. a\n~~~')), [['<figure data-type="list" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><ol><li>a</li></ol></div></figure>'], '']);
       assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n|\n|-\n|\n~~~')), [['<figure data-type="table" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><table><thead><tr></tr></thead><tbody><tr></tr></tbody></table></div></figure>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n```\n\n```\n~~~')), [['<figure data-type="text" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><pre class="text" translate="no"></pre></div></figure>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n```\n~~~\n```\n\n~~~')), [['<figure data-type="text" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span></figcaption><div><pre class="text" translate="no">~~~</pre></div></figure>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n```\n```\n\ncaption\n~~~')), [['<figure data-type="text" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span>caption</figcaption><div><pre class="text" translate="no"></pre></div></figure>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~figure [$group-name]\n```\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('~~~figure [$group-name]\n```\n~~~\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('~~~figure [$group-name]\n```\n```\n\ncaption\n~~~')), [['<figure data-type="text" data-label="group-name" data-group="group"><figcaption><span class="figindex"></span>caption</figcaption><div><pre class="text"></pre></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~~~')), [['<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>'], '']);

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

@@ -6,16 +6,17 @@ import { label } from '../../inline/extension/label';
 import { ulist } from '../ulist';
 import { olist } from '../olist';
 import { table as styled_table } from '../table';
+import { indentblock } from '../indentblock';
 import { codeblock, segment_ as seg_code } from '../codeblock';
 import { mathblock, segment_ as seg_math } from '../mathblock';
-import { blockquote, segment as seg_blockquote } from '../blockquote';
 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 { localize } from '../../locale';
 import { visualize } from '../../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { unshift } from 'spica/array';
 
@@ -33,8 +34,8 @@ export const segment: FigureParser.SegmentParser = block(match(
           union([
             seg_code,
             seg_math,
-            seg_blockquote,
             seg_table,
+            seg_blockquote,
             seg_placeholder,
             some(contentline, closer),
           ]),
@@ -57,14 +58,16 @@ export const figure: FigureParser = block(rewrite(segment, fmap(
         ulist,
         olist,
         styled_table,
+        indentblock,
         codeblock,
         mathblock,
-        blockquote,
         example,
         table,
+        blockquote,
         placeholder,
-        line(media),
-        line(shortmedia),
+        block(line(media)),
+        block(line(shortmedia)),
+        fmap(some(contentline), () => [html('br')]),
       ])),
       emptyline,
       block(localize(
@@ -101,6 +104,9 @@ function attributes(label: string, param: string, content: HTMLElement, caption:
     case 'A':
       type = 'media';
       break;
+    case 'BR':
+      type = 'invalid';
+      break;
     case 'text':
     case 'code':
     case 'math':
@@ -111,6 +117,10 @@ function attributes(label: string, param: string, content: HTMLElement, caption:
       assert(false);
   }
   const invalid =
+    type === 'invalid' && content.tagName === 'BR' && {
+      'data-invalid-type': 'content',
+      'data-invalid-message': 'Invalid content',
+    } ||
     /^[^-]+-(?:[0-9]+\.)*0$/.test(label) && {
       'data-invalid-type': 'label',
       'data-invalid-message': 'The last part of the fixed label numbers must not be 0',

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

@@ -15,13 +15,13 @@ describe('Unit: parser/block/extension/message', () => {
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('~~~message/note\n~~~')), [['<div class="message type-note"><h6>Note</h6></div>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~message/note\n\n~~~')), [['<div class="message type-note"><h6>Note</h6></div>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~message/note\na\n~~~')), [['<div class="message type-note"><h6>Note</h6><p>a</p></div>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~message/note\na\n\n- \n~~~')), [['<div class="message type-note"><h6>Note</h6><p>a</p><ul><li></li></ul></div>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~message/note\n# a\n~~~')), [['<div class="message type-note"><h6>Note</h6><p># a</p></div>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~message/caution\n~~~')), [['<div class="message type-caution"><h6>Caution!</h6></div>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~message/warning\n~~~')), [['<div class="message type-warning"><h6>WARNING!!</h6></div>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~message/note\n~~~')), [['<div class="message" data-type="note"><h6>Note</h6></div>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~message/note\n\n~~~')), [['<div class="message" data-type="note"><h6>Note</h6></div>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~message/note\na\n~~~')), [['<div class="message" data-type="note"><h6>Note</h6><p>a</p></div>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~message/note\na\n\n- \n~~~')), [['<div class="message" data-type="note"><h6>Note</h6><p>a</p><ul><li></li></ul></div>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~message/note\n# a\n~~~')), [['<div class="message" data-type="note"><h6>Note</h6><p># a</p></div>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~message/caution\n~~~')), [['<div class="message" data-type="caution"><h6>Caution!</h6></div>'], '']);
+      assert.deepStrictEqual(inspect(parser('~~~message/warning\n~~~')), [['<div class="message" data-type="warning"><h6>WARNING!!</h6></div>'], '']);
     });
 
   });

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

@@ -7,11 +7,13 @@ import { ulist } from '../ulist';
 import { olist } from '../olist';
 import { ilist } from '../ilist';
 import { table } from '../table';
+import { indentblock } from '../indentblock';
 import { codeblock } from '../codeblock';
 import { mathblock } from '../mathblock';
+import { sidefence } from '../sidefence';
 import { blockquote } from '../blockquote';
 import { paragraph } from '../paragraph';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
 import MessageParser = ExtensionParser.MessageParser;
@@ -41,7 +43,7 @@ export const message: MessageParser = block(validate('~~~', fmap(
         }, `${opener}${body}${closer}`)];
     }
     return [
-      html('div', { class: `message type-${type}` }, unshift(
+      html('div', { class: `message`, 'data-type': type }, unshift(
         [html('h6', title(type))],
         [...segment(body)].reduce((acc, seg) => push(acc, eval(content(seg, context), [])), []))),
     ];
@@ -65,8 +67,10 @@ const content: MessageParser.ContentParser = union([
   olist,
   ilist,
   table,
+  indentblock,
   codeblock,
   mathblock,
+  sidefence,
   blockquote,
   paragraph,
 ]);

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

@@ -1,6 +1,7 @@
 import { ExtensionParser } from '../../block';
 import { block, validate, fence, clear, fmap } from '../../../combinator';
-import { html } from 'typed-dom';
+import { segment as label } from '../../inline/extension/label';
+import { html } from 'typed-dom/dom';
 
 const opener = /^(~{3,})(?!~)[^\n]*(?:$|\n)/;
 
@@ -12,12 +13,17 @@ export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(v
 
 export const placeholder: ExtensionParser.PlaceholderParser = block(validate('~~~', fmap(
   fence(opener, Infinity),
-  ([body, closer, opener, delim]) => [
+  ([body, closer, opener, delim]: string[], _, context) => [
     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 syntax',
+      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid extension name',
+      ...closer && (opener.slice(delim.length).split(/\s/, 1)[0] === 'figure' || label(opener.slice(delim.length), context)) && {
+        'data-invalid-syntax': 'figure',
+        'data-invalid-type': 'content',
+        'data-invalid-message': 'Invalid content',
+      },
     }, `${opener}${body}${closer}`)
   ])));

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

@@ -1,7 +1,7 @@
 import { table } from './table';
 import { some } from '../../../combinator';
 import { inspect } from '../../../debug.test';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 describe('Unit: parser/block/extension/table', () => {
   describe('table', () => {

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

@@ -7,7 +7,7 @@ import { inline } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { localize } from '../../locale';
 import { visualize } from '../../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift, splice } from 'spica/array';
 
 import TableParser = ExtensionParser.TableParser;

package/src/parser/block/heading.ts

@@ -3,7 +3,7 @@ import { union, some, block, line, validate, focus, rewrite, context, open, trim
 import { inline, indexee, indexer } from '../inline';
 import { str } from '../source';
 import { visualize } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
   /^#+[^\S\n]+\S[^\n]*(?:\n#+(?!\S)[^\n]*)*(?:$|\n)/,

package/src/parser/block/horizontalrule.ts

@@ -1,6 +1,6 @@
 import { HorizontalRuleParser } from '../block';
 import { block, line, focus } from '../../combinator';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 export const horizontalrule: HorizontalRuleParser = block(line(focus(
   /^-{3,}[^\S\n]*(?:$|\n)/,

package/src/parser/block/ilist.ts

@@ -4,7 +4,7 @@ import { ulist_, fillFirstLine } from './ulist';
 import { olist_ } from './olist';
 import { inline } from '../inline';
 import { contentline } from '../source';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const ilist: IListParser = lazy(() => block(validate(
   /^[-+*](?=[^\S\n]|\n[^\S\n]*\S)/,