securemark 0.240.2 → 0.243.0

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

@@ -0,0 +1,30 @@
+import { indentblock } from './indentblock';
+import { some } from '../../combinator';
+import { inspect } from '../../debug.test';
+
+describe('Unit: parser/block/indentblock', () => {
+  describe('indentblock', () => {
+    const parser = (source: string) => some(indentblock)(source, {});
+
+    it('invalid', () => {
+      assert.deepStrictEqual(inspect(parser('')), undefined);
+      assert.deepStrictEqual(inspect(parser('\na')), undefined);
+      assert.deepStrictEqual(inspect(parser(' a')), undefined);
+      assert.deepStrictEqual(inspect(parser(' \ta')), undefined);
+      assert.deepStrictEqual(inspect(parser('  a\nb')), undefined);
+      assert.deepStrictEqual(inspect(parser('  a\n b')), undefined);
+    });
+
+    it('valid', () => {
+      assert.deepStrictEqual(inspect(parser('  a')), [['<pre class="text">a</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('  a ')), [['<pre class="text">a </pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('  a \n')), [['<pre class="text">a </pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('  a \n    b')), [['<pre class="text">a <br>  b</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('  a\\\n  b')), [['<pre class="text">a\\<br>b</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('\ta')), [['<pre class="text">a</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('\t a')), [['<pre class="text"> a</pre>'], '']);
+    });
+
+  });
+
+});

package/src/parser/block/indentblock.ts

@@ -0,0 +1,13 @@
+import { IndentBlockParser } from '../block';
+import { union, block, validate, indent, convert } from '../../combinator';
+import { codeblock } from './codeblock';
+
+// 空行を含むインデントブロックはインデントの違いによるセグメント分割の境界が視認不能となるため採用しない
+
+export const indentblock: IndentBlockParser = block(validate(/^(?:  |\t)/, indent(convert(
+  source => {
+    const fence = (source.match(/^`{3,}(?=[^\S\n]*$)/mg) ?? [])
+      .reduce((max, fence) => fence > max ? fence : max, '``') + '`';
+    return `${fence}\n${source}\n${fence}`;
+  },
+  union([codeblock])), true)));

package/src/parser/block/mathblock.ts

@@ -1,7 +1,7 @@
 import { undefined } from 'spica/global';
 import { MathBlockParser } from '../block';
 import { block, validate, fence, clear, fmap } from '../../combinator';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 const opener = /^(\${2,})(?!\$)([^\n]*)(?:$|\n)/;
 

package/src/parser/block/olist.ts

@@ -5,7 +5,7 @@ import { checkbox, ulist_, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
 import { inline, indexee, indexer } from '../inline';
 import { contentline } from '../source';
-import { html, define, defrag } from 'typed-dom';
+import { html, define, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { shift } from 'spica/array';
 
@@ -31,17 +31,17 @@ export const olist_: OListParser = lazy(() => block(union([
     memoize(ms => list(type(ms[1]), '('), ms => type(ms[1]).charCodeAt(0) || 0, [])),
 ])));
 
-const list = (type: string, delim: string): OListParser.ListParser => fmap(
+const list = (type: string, form: string): OListParser.ListParser => fmap(
   some(creator(union([
     indexee(fmap(fallback(
       inits([
-        line(open(heads[delim], trim(subsequence([checkbox, trimStart(some(union([indexer, inline])))])), true)),
+        line(open(heads[form], trim(subsequence([checkbox, trimStart(some(union([indexer, inline])))])), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       invalid),
       (ns: [string, ...(HTMLElement | string)[]]) => [html('li', { 'data-marker': ns[0] }, defrag(fillFirstLine(shift(ns)[1])))]), true),
   ]))),
-  es => [format(html('ol', es), type, delim)]);
+  es => [format(html('ol', es), type, form)]);
 
 const heads = {
   '.': focus(
@@ -107,13 +107,13 @@ function initial(type: string): RegExp {
   }
 }
 
-function format(el: HTMLOListElement, type: string, delim: string): HTMLOListElement {
+function format(el: HTMLOListElement, type: string, form: string): HTMLOListElement {
   if (el.firstElementChild?.firstElementChild?.classList.contains('checkbox')) {
     el.setAttribute('class', 'checklist');
   }
   define(el, {
     type: type || undefined,
-    'data-format': delim === '.' ? undefined : 'paren',
+    'data-format': form === '.' ? undefined : 'paren',
     'data-type': style(type) || undefined,
   });
   const marker = el.firstElementChild?.getAttribute('data-marker')!.match(initial(type))?.[0] ?? '';

package/src/parser/block/paragraph.ts

@@ -3,7 +3,7 @@ import { union, some, block, trim, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { localize } from '../locale';
 import { visualize } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const paragraph: ParagraphParser = block(localize(fmap(
   trim(visualize(some(union([inline])))),

package/src/parser/block/reply/cite.ts

@@ -2,7 +2,7 @@ import { ReplyParser } from '../../block';
 import { union, tails, line, validate, focus, creator, reverse, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
-import { html, define, defrag } from 'typed-dom';
+import { html, define, defrag } from 'typed-dom/dom';
 
 export const cite: ReplyParser.CiteParser = creator(line(fmap(validate(
   '>>',

package/src/parser/block/reply/quote.ts

@@ -4,7 +4,7 @@ import { union, some, block, line, validate, rewrite, creator, lazy, fmap } from
 import { math } from '../../inline/math';
 import { str, anyline } from '../../source';
 import { autolink } from '../../autolink';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const syntax = /^>+(?=[^\S\n])|^>(?=[^\s>])|^>+(?=[^\s>])(?![0-9a-z]+(?:-[0-9a-z]+)*(?![0-9A-Za-z@#:]))/;
 

package/src/parser/block/reply.ts

@@ -6,7 +6,7 @@ import { inline } 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, pop } from 'spica/array';
 
 /*

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

@@ -0,0 +1,66 @@
+import { sidefence } from './sidefence';
+import { some } from '../../combinator';
+import { inspect } from '../../debug.test';
+
+describe('Unit: parser/block/sidefence', () => {
+  describe('sidefence', () => {
+    const parser = (source: string) => some(sidefence)(source, {});
+
+    it('invalid', () => {
+      assert.deepStrictEqual(inspect(parser('')), undefined);
+      assert.deepStrictEqual(inspect(parser('\n')), undefined);
+      assert.deepStrictEqual(inspect(parser('|')), undefined);
+      assert.deepStrictEqual(inspect(parser('|a')), undefined);
+      assert.deepStrictEqual(inspect(parser('|\n')), undefined);
+      assert.deepStrictEqual(inspect(parser(' | ')), undefined);
+      assert.deepStrictEqual(inspect(parser('||')), undefined);
+    });
+
+    it('basic', () => {
+      assert.deepStrictEqual(inspect(parser('| ')), [['<blockquote class="invalid"></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| \\')), [['<blockquote class="invalid"><pre>\\</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| \\\n')), [['<blockquote class="invalid"><pre>\\</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a')), [['<blockquote class="invalid"><pre>a</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n')), [['<blockquote class="invalid"><pre>a</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\nb')), undefined);
+      assert.deepStrictEqual(inspect(parser('| a\n b ')), undefined);
+      assert.deepStrictEqual(inspect(parser('| a\n|')), [['<blockquote class="invalid"><pre>a<br></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n>>1')), undefined);
+      assert.deepStrictEqual(inspect(parser('| a\n| b ')), [['<blockquote class="invalid"><pre>a<br>b </pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n|\n')), [['<blockquote class="invalid"><pre>a<br></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n|\nb')), undefined);
+      assert.deepStrictEqual(inspect(parser('| a\n|\n b ')), undefined);
+      assert.deepStrictEqual(inspect(parser('| a\n|\n|')), [['<blockquote class="invalid"><pre>a<br><br></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n|\n>>1')), undefined);
+      assert.deepStrictEqual(inspect(parser('| a\n|\n| b ')), [['<blockquote class="invalid"><pre>a<br><br>b </pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\\\nb')), undefined);
+      assert.deepStrictEqual(inspect(parser('|  a ')), [['<blockquote class="invalid"><pre> a </pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| \na')), undefined);
+      assert.deepStrictEqual(inspect(parser('|\na')), undefined);
+      assert.deepStrictEqual(inspect(parser('|\n a')), undefined);
+      assert.deepStrictEqual(inspect(parser('|\n|')), [['<blockquote class="invalid"><pre><br></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('|\n| a')), [['<blockquote class="invalid"><pre><br>a</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| http://host')), [['<blockquote class="invalid"><pre><a href="http://host" target="_blank">http://host</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| !http://host')), [['<blockquote class="invalid"><pre>!<a href="http://host" target="_blank">http://host</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| #a')), [['<blockquote class="invalid"><pre><a href="/hashtags/a" class="hashtag">#a</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| @a#b')), [['<blockquote class="invalid"><pre><a href="/@a?ch=b" class="channel">@a#b</a></pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| >>1\n| | b')), [['<blockquote class="invalid"><pre><a href="?at=1" class="anchor">&gt;&gt;1</a><br>| b</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| >>1\n| | b\n| c')), [['<blockquote class="invalid"><pre><a href="?at=1" class="anchor">&gt;&gt;1</a><br>| b<br>c</pre></blockquote>'], '']);
+    });
+
+    it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('| a\n||')), [['<blockquote class="invalid"><pre>a</pre><blockquote></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n|| b\n| c')), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b</pre></blockquote><pre>c</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n|| b\n|| c')), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b<br>c</pre></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('| a\n|| b\n||| c')), [['<blockquote class="invalid"><pre>a</pre><blockquote><pre>b</pre><blockquote><pre>c</pre></blockquote></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('|| a')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('|| a\n|')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('|| a\n| b')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote><pre>b</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('|| a\n||| b\n| c')), [['<blockquote class="invalid"><blockquote><pre>a</pre><blockquote><pre>b</pre></blockquote></blockquote><pre>c</pre></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('|| a\n| b\n||| c')), [['<blockquote class="invalid"><blockquote><pre>a</pre></blockquote><pre>b</pre><blockquote><blockquote><pre>c</pre></blockquote></blockquote></blockquote>'], '']);
+      assert.deepStrictEqual(inspect(parser('||| a\n|| b\n| c')), [['<blockquote class="invalid"><blockquote><blockquote><pre>a</pre></blockquote><pre>b</pre></blockquote><pre>c</pre></blockquote>'], '']);
+    });
+
+  });
+
+});

package/src/parser/block/sidefence.ts

@@ -0,0 +1,31 @@
+import { SidefenceParser } from '../block';
+import { union, some, block, focus, rewrite, creator, convert, lazy, fmap } from '../../combinator';
+import { autolink } from '../autolink';
+import { contentline } from '../source';
+import { html, define, defrag } from 'typed-dom/dom';
+
+export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
+  /^(?=\|+(?:[^\S\n]|\n\|))(?:\|+(?:[^\S\n][^\n]*)?(?:$|\n))+$/,
+  union([source])),
+  ([el]) => [
+    define(el, {
+      class: 'invalid',
+      'data-invalid-syntax': 'sidefence',
+      'data-invalid-type': 'syntax',
+      'data-invalid-message': 'Reserved syntax',
+    }),
+  ])));
+
+const opener = /^(?=\|\|+(?:$|\s))/;
+const unindent = (source: string) => source.replace(/(^|\n)\|(?:[^\S\n]|(?=\|*(?:$|\s)))|\n$/g, '$1');
+
+const source: SidefenceParser.SourceParser = lazy(() => fmap(
+  some(creator(union([
+    focus(
+      /^(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/,
+      convert(unindent, source)),
+    rewrite(
+      some(contentline, opener),
+      convert(unindent, fmap(some(autolink), ns => [html('pre', defrag(ns))]))),
+  ]))),
+  ns => [html('blockquote', ns)]));

package/src/parser/block/table.ts

@@ -2,7 +2,7 @@ import { TableParser } from '../block';
 import { union, sequence, some, block, line, validate, focus, rewrite, creator, surround, open, fallback, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { contentline } from '../source';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { push } from 'spica/array';
 
 import RowParser = TableParser.RowParser;

package/src/parser/block/ulist.ts

@@ -3,7 +3,7 @@ import { union, inits, subsequence, some, block, line, validate, indent, focus,
 import { olist_ } from './olist';
 import { ilist_ } from './ilist';
 import { inline, indexer, indexee } from '../inline';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 import { contentline } from '../source';
 

package/src/parser/block.ts

@@ -9,13 +9,15 @@ import { olist } from './block/olist';
 import { ilist } from './block/ilist';
 import { dlist } from './block/dlist';
 import { table } from './block/table';
-import { blockquote } from './block/blockquote';
+import { indentblock } from './block/indentblock';
 import { codeblock } from './block/codeblock';
 import { mathblock } from './block/mathblock';
 import { extension } from './block/extension';
+import { sidefence } from './block/sidefence';
+import { blockquote } from './block/blockquote';
 import { reply } from './block/reply';
 import { paragraph } from './block/paragraph';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 import { rnd0Z } from 'spica/random';
 
 export import BlockParser = MarkdownParser.BlockParser;
@@ -26,9 +28,11 @@ export import OListParser = BlockParser.OListParser;
 export import IListParser = BlockParser.IListParser;
 export import DListParser = BlockParser.DListParser;
 export import TableParser = BlockParser.TableParser;
+export import IndentBlockParser = BlockParser.IndentBlockParser;
 export import CodeBlockParser = BlockParser.CodeBlockParser;
 export import MathBlockParser = BlockParser.MathBlockParser;
 export import ExtensionParser = BlockParser.ExtensionParser;
+export import SidefenceParser = BlockParser.SidefenceParser;
 export import BlockquoteParser = BlockParser.BlockquoteParser;
 export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
@@ -44,9 +48,11 @@ export const block: BlockParser = creator(error(
     ilist,
     dlist,
     table,
+    indentblock,
     codeblock,
     mathblock,
     extension,
+    sidefence,
     blockquote,
     reply,
     paragraph

package/src/parser/header.ts

@@ -3,7 +3,7 @@ import { union, inits, some, block, line, validate, focus, rewrite, guard, clear
 import { segment } from './segment';
 import { str } from './source';
 import { normalize } from './api/normalize';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const header: MarkdownParser.HeaderParser = lazy(() => validate(
   /^---+[^\S\v\f\r\n]*\r?\n[^\S\n]*(?=\S)/,

package/src/parser/inline/annotation.ts

@@ -3,7 +3,7 @@ import { AnnotationParser } from '../inline';
 import { union, some, validate, guard, context, creator, surround, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { startLoose, trimSpaceStart, trimNodeEnd } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => creator(validate('((', '))', '\n', fmap(surround(
   '((',

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

@@ -2,7 +2,7 @@ import { AutolinkParser } from '../../inline';
 import { union, tails, verify, rewrite, context, open, convert, fmap, lazy } from '../../../combinator';
 import { link } from '../link';
 import { str } from '../../source';
-import { define } from 'typed-dom';
+import { define } from 'typed-dom/dom';
 
 // https://example/@user must be a user page or a redirect page going there.
 

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

@@ -1,7 +1,7 @@
 import { AutolinkParser } from '../../inline';
 import { union, validate, focus, context, convert, fmap, lazy } from '../../../combinator';
 import { link } from '../link';
-import { define } from 'typed-dom';
+import { define } from 'typed-dom/dom';
 
 // Timeline(pseudonym): user/tid
 // Thread(anonymous): cid

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

@@ -3,7 +3,7 @@ import { sequence, some, validate, bind } from '../../../combinator';
 import { account } from './account';
 import { hashtag } from './hashtag';
 import { stringify } from '../../util';
-import { define } from 'typed-dom';
+import { define } from 'typed-dom/dom';
 
 // https://example/@user?ch=a+b must be a user channel page or a redirect page going there.
 

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

@@ -1,7 +1,7 @@
 import { AutolinkParser } from '../../inline';
 import { verify, rewrite, creator } from '../../../combinator';
 import { str } from '../../source';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 // https://html.spec.whatwg.org/multipage/input.html
 

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

@@ -3,7 +3,7 @@ import { union, rewrite, context, open, convert, fmap, lazy } from '../../../com
 import { link } from '../link';
 import { emoji } from './hashtag';
 import { str } from '../../source';
-import { define } from 'typed-dom';
+import { define } from 'typed-dom/dom';
 
 export const hashnum: AutolinkParser.HashnumParser = lazy(() => fmap(rewrite(
   open('#', str(new RegExp(String.raw`^[0-9]{1,16}(?![^\p{C}\p{S}\p{P}\s]|${emoji}|['_])`, 'u'))),

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

@@ -2,7 +2,7 @@ import { AutolinkParser } from '../../inline';
 import { union, tails, verify, rewrite, context, open, convert, fmap, lazy } from '../../../combinator';
 import { link } from '../link';
 import { str } from '../../source';
-import { define } from 'typed-dom';
+import { define } from 'typed-dom/dom';
 
 // https://example/hashtags/a must be a hashtag page or a redirect page going there.
 

package/src/parser/inline/bracket.ts

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

package/src/parser/inline/code.ts

@@ -1,6 +1,6 @@
 import { CodeParser } from '../inline';
 import { validate, creator, match } from '../../combinator';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 export const code: CodeParser = creator(validate('`', match(
   /^(`+)(?!`)([^\n]*?[^`\n])\1(?!`)/,

package/src/parser/inline/comment.ts

@@ -2,7 +2,7 @@ import { CommentParser } from '../inline';
 import { union, some, validate, creator, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 

package/src/parser/inline/deletion.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { blank } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const deletion: DeletionParser = lazy(() => creator(surround(

package/src/parser/inline/emphasis.ts

@@ -4,7 +4,7 @@ import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
 import { startTight, blank } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const emphasis: EmphasisParser = lazy(() => creator(surround(

package/src/parser/inline/emstrong.ts

@@ -6,7 +6,7 @@ import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
 import { startTight, blank } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([

package/src/parser/inline/extension/index.ts

@@ -5,7 +5,7 @@ import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str, stropt } from '../../source';
 import { startTight, trimNodeEnd } from '../../util';
-import { html, define, defrag } from 'typed-dom';
+import { html, define, defrag } from 'typed-dom/dom';
 import { join } from 'spica/array';
 
 import IndexParser = ExtensionParser.IndexParser;

package/src/parser/inline/extension/indexee.ts

@@ -2,7 +2,7 @@ import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../../../markdown';
 import { Parser } from '../../../combinator/data/parser';
 import { fmap } from '../../../combinator';
-import { define } from 'typed-dom';
+import { define } from 'typed-dom/dom';
 
 export function indexee<P extends Parser<unknown, MarkdownParser.Context>>(parser: P, optional?: boolean): P;
 export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>, optional?: boolean): Parser<HTMLElement> {

package/src/parser/inline/extension/indexer.ts

@@ -1,7 +1,7 @@
 import { ExtensionParser } from '../../inline';
 import { union, verify, focus, creator, context, surround, fmap } from '../../../combinator';
 import { index } from './index';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 export const indexer: ExtensionParser.IndexerParser = creator(fmap(verify(surround(
   /^\s+(?=\[#\S)/,

package/src/parser/inline/extension/label.ts

@@ -2,7 +2,7 @@ import { Array } from 'spica/global';
 import { ExtensionParser } from '../../inline';
 import { union, validate, guard, creator, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 import { join } from 'spica/array';
 
 const body = str(/^\$[A-Za-z]*(?:(?:-[A-Za-z][0-9A-Za-z]*)+|-(?:(?:0|[1-9][0-9]*)\.)*(?:0|[1-9][0-9]*)(?![0-9A-Za-z]))/);

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

@@ -3,7 +3,7 @@ import { union, some, validate, creator, surround, lazy } from '../../../combina
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { startTight } from '../../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 // Don't use the symbols already used: !#$@&*+~=
@@ -14,12 +14,12 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => creator
   str(/^\[[:^]/),
   startTight(some(union([inline]), ']')),
   str(']'), false,
-  ([, bs], rest) => [[
+  ([as, bs], rest) => [[
     html('span', {
       class: 'invalid',
       'data-invalid-syntax': 'extension',
       'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Invalid symbol',
+      'data-invalid-message': `Reserved start symbol "${as[0][1]}" cannot be used in "[]"`,
     }, defrag(bs)),
   ], rest],
   ([as, bs], rest) => [unshift(as, bs), rest]))));

package/src/parser/inline/html.ts

@@ -6,7 +6,7 @@ import { union, some, validate, context, creator, surround, open, match, lazy }
 import { inline } from '../inline';
 import { str } from '../source';
 import { startLoose, blank } from '../util';
-import { html as h, defrag } from 'typed-dom';
+import { html as h, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { Cache } from 'spica/cache';
 import { unshift, push, splice, join } from 'spica/array';

package/src/parser/inline/htmlentity.ts

@@ -1,7 +1,7 @@
 import { undefined } from 'spica/global';
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { union, validate, focus, creator, fmap } from '../../combinator';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 
 export const unsafehtmlentity: UnsafeHTMLEntityParser = creator(validate('&', focus(

package/src/parser/inline/insertion.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { blank } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const insertion: InsertionParser = lazy(() => creator(surround(

package/src/parser/inline/link.ts

@@ -8,7 +8,7 @@ import { attributes } from './html';
 import { autolink } from '../autolink';
 import { str } from '../source';
 import { startLoose, trimSpaceStart, trimNodeEnd, stringify } from '../util';
-import { html, define, defrag } from 'typed-dom';
+import { html, define, defrag } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 
 const optspec = {

package/src/parser/inline/mark.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { startTight, blank } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const mark: MarkParser = lazy(() => creator(surround(

package/src/parser/inline/math.ts

@@ -1,7 +1,7 @@
 import { MathParser } from '../inline';
 import { union, some, validate, rewrite, creator, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
-import { html } from 'typed-dom';
+import { html } from 'typed-dom/dom';
 
 const disallowedCommand = /\\(?:begin|tiny|huge|large)(?![0-9a-z])/i;
 

package/src/parser/inline/media.ts

@@ -6,7 +6,7 @@ import { link, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
-import { html, define } from 'typed-dom';
+import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push, join } from 'spica/array';
 

package/src/parser/inline/reference.ts

@@ -4,7 +4,7 @@ import { union, subsequence, some, validate, verify, focus, guard, context, crea
 import { inline } from '../inline';
 import { str } from '../source';
 import { startLoose, isStartLoose, trimSpaceStart, trimNodeEnd, stringify } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 
 export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]', '\n', fmap(surround(
   '[[',

package/src/parser/inline/ruby.ts

@@ -5,7 +5,7 @@ import { sequence, validate, verify, focus, creator, surround, lazy, bind } from
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
 import { isStartTightNodes } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift, push, join } from 'spica/array';
 
 export const ruby: RubyParser = lazy(() => creator(validate('[', ')', '\n', bind(verify(

package/src/parser/inline/strong.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { startTight, blank } from '../util';
-import { html, defrag } from 'typed-dom';
+import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const strong: StrongParser = lazy(() => creator(surround(