securemark 0.278.0 → 0.279.1

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

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../block';
-import { union, inits, sequence, some, state, block, line, fence, rewrite, close, match, convert, fallback, fmap } from '../../../combinator';
+import { union, inits, sequence, some, block, line, fence, rewrite, close, match, convert, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
 import { label, segment as seg_label } from '../../inline/extension/label';
 import { ulist } from '../ulist';
@@ -12,7 +12,6 @@ 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 { State } from '../../context';
 import { visualize, trimBlankStart, trimNodeEnd } from '../../visibility';
 import { memoize } from 'spica/memoize';
 import { html, defrag } from 'typed-dom/dom';
@@ -43,7 +42,7 @@ export const segment: FigureParser.SegmentParser = block(match(
       ]),
     ]),
     closer),
-  ([, fence]) => fence.length, [])));
+  ([, fence]) => fence.length, {})));
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
@@ -64,9 +63,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
         line(shortmedia),
       ])),
       emptyline,
-      block(
-        state(State.media,
-        visualize(trimBlankStart(some(inline))))),
+      block(visualize(trimBlankStart(some(inline)))),
     ]),
   ])),
   ([label, param, content, ...caption]: [HTMLAnchorElement, string, ...HTMLElement[]]) => [

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

@@ -11,6 +11,7 @@ import { codeblock } from '../codeblock';
 import { mathblock } from '../mathblock';
 import { sidefence } from '../sidefence';
 import { blockquote } from '../blockquote';
+import { mediablock } from '../mediablock';
 import { paragraph } from '../paragraph';
 import { unshift, push } from 'spica/array';
 import { html } from 'typed-dom/dom';
@@ -74,5 +75,6 @@ const content: MessageParser.ContentParser = union([
   mathblock,
   sidefence,
   blockquote,
+  mediablock,
   paragraph,
 ]);

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

@@ -1,8 +1,8 @@
 import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
 import { Tree, eval } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, creation, block, line, validate, fence, rewrite, open, clear, convert, dup, lazy, fmap } from '../../../combinator';
-import { inline } from '../../inline';
+import { union, subsequence, inits, some, creation, block, line, validate, fence, rewrite, surround, open, clear, convert, dup, lazy, fmap } from '../../../combinator';
+import { inline, medialink, media, shortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { visualize, trimBlankStart, trimNodeEnd } from '../../visibility';
 import { unshift, splice } from 'spica/array';
@@ -84,7 +84,12 @@ const head: CellParser.HeadParser = creation(1, false, block(fmap(open(
       anyline,
       some(contentline, delimiter),
     ]),
-    open(/^(?:\s*\n|\s)/, visualize(trimBlankStart(some(union([inline])))), true)),
+    union([
+      block(surround(/^[^\n]/, medialink, /^\s*$/)),
+      block(surround(/^[^\n]/, media, /^\s*$/)),
+      block(surround(/^[^\n]/, shortmedia, /^\s*$/)),
+      open(/^(?:\s*\n|\s)/, visualize(trimBlankStart(some(inline))), true),
+    ])),
   true),
   ns => [html('th', attributes(ns.shift()! as string), trimNodeEnd(defrag(ns)))]),
   false));
@@ -96,7 +101,12 @@ const data: CellParser.DataParser = creation(1, false, block(fmap(open(
       anyline,
       some(contentline, delimiter),
     ]),
-    open(/^(?:\s*\n|\s)/, visualize(some(union([inline]))), true)),
+    union([
+      block(surround(/^[^\n]/, medialink, /^\s*$/)),
+      block(surround(/^[^\n]/, media, /^\s*$/)),
+      block(surround(/^[^\n]/, shortmedia, /^\s*$/)),
+      open(/^(?:\s*\n|\s)/, visualize(some(inline)), true),
+    ])),
   true),
   ns => [html('td', attributes(ns.shift()! as string), trimNodeEnd(defrag(ns)))]),
   false));

package/src/parser/block/ilist.ts

@@ -1,15 +1,13 @@
 import { IListParser } from '../block';
-import { union, inits, some, creation, state, block, line, validate, indent, open, fallback, lazy, fmap } from '../../combinator';
-import { ulist_, fillFirstLine } from './ulist';
-import { olist_, invalid } from './olist';
+import { union, inits, some, creation, block, line, validate, indent, open, fallback, lazy, fmap } from '../../combinator';
+import { ulist_, invalid, fillFirstLine } from './ulist';
+import { olist_ } from './olist';
 import { inline } from '../inline';
-import { State } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ilist: IListParser = lazy(() => block(validate(
   /^[-+*](?=[^\S\n]|\n[^\S\n]*\S)/,
-  state(State.media,
-  ilist_))));
+  ilist_)));
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(
   /^[-+*](?:$|\s)/,

package/src/parser/block/mediablock.ts

@@ -0,0 +1,26 @@
+import { MediaBlockParser } from '../block';
+import { union, inits, some, block, line, validate, fallback, fmap } from '../../combinator';
+import { medialink, media, shortmedia } from '../inline';
+import { html } from 'typed-dom/dom';
+
+export const mediablock: MediaBlockParser = block(validate(['[!', '!'], fmap(
+  inits([
+    line(union([
+      medialink,
+      media,
+      shortmedia,
+    ])),
+    some(line(fallback(union([
+      medialink,
+      media,
+      shortmedia,
+    ]), ({ source }) => [[html('div', [html('span', attrs, source.replace('\n', ''))])], '']))),
+  ]),
+  ns => [html('div', ns)])));
+
+const attrs = {
+  class: 'invalid',
+  'data-invalid-syntax': 'mediablock',
+  'data-invalid-type': 'syntax',
+  'data-invalid-message': 'Not media syntax',
+} as const;

package/src/parser/block/olist.ts

@@ -1,12 +1,9 @@
 import { OListParser } from '../block';
-import { Parser } from '../../combinator/data/parser';
-import { union, inits, subsequence, some, creation, state, block, line, validate, indent, focus, rewrite, open, close, match, trim, fallback, lazy, fmap } from '../../combinator';
-import { checkbox, ulist_, fillFirstLine } from './ulist';
+import { union, inits, subsequence, some, creation, block, line, validate, indent, focus, open, close, match, trim, fallback, lazy, fmap } from '../../combinator';
+import { ulist_, checkbox, invalid, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
 import { inline, indexee, indexer } from '../inline';
 import { index } from '../inline/extension/index';
-import { contentline } from '../source';
-import { State } from '../context';
 import { visualize, trimBlank } from '../visibility';
 import { memoize } from 'spica/memoize';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -21,8 +18,7 @@ export const olist: OListParser = lazy(() => block(validate(
     /^([0-9]+|[a-z]+|[A-Z]+)(?:-[0-9]+)*\.(?=[^\S\n]|\n[^\S\n]*\S)/.source,
     /^\(([0-9]+|[a-z]+)\)(?:-[0-9]+)*(?=[^\S\n]|\n[^\S\n]*\S)/.source,
   ].join('|')),
-  state(State.media,
-  olist_))));
+  olist_)));
 
 export const olist_: OListParser = lazy(() => block(union([
   match(
@@ -59,18 +55,6 @@ const heads = {
     ({ source }) => [[source.trimEnd().replace(/^\($/, '(1)').replace(/^\((\w+)$/, '($1)')], '']),
 } as const;
 
-export const invalid = rewrite(
-  inits([contentline, indent<Parser<string>>(({ source }) => [[source], ''])]),
-  ({ source }) => [[
-    '',
-    html('span', {
-      class: 'invalid',
-      'data-invalid-syntax': 'list',
-      'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Fix the indent or the head of the list item',
-    }, source.replace('\n', ''))
-  ], '']);
-
 function idx(value: string): number {
   switch (value) {
     case 'i':

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

@@ -35,9 +35,9 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('==a\n<wbr>==\nb')), [['<p>==a<br><wbr>==<br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('http://host#\\')), [['<p><a class="url" href="http://host#\\" target="_blank">http://host#\\</a></p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\nhttp://host#\\ \nb')), [['<p>a<br><a class="url" href="http://host#\\" target="_blank">http://host#\\</a><br>b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('!http://host#\\')), [['<p><a href="http://host#\\" target="_blank"><img class="media" data-src="http://host#\\" alt=""></a></p>'], '']);
-      assert.deepStrictEqual(inspect(parser('!http://host#\\ a')), [['<p>!<a class="url" href="http://host#" target="_blank">http://host#</a> a</p>'], '']);
-      assert.deepStrictEqual(inspect(parser(' !http://host#\\')), [['<p> !<a class="url" href="http://host#" target="_blank">http://host#</a></p>'], '']);
+      //assert.deepStrictEqual(inspect(parser('!http://host#\\')), [['<p><a href="http://host#\\" target="_blank"><img class="media" data-src="http://host#\\" alt=""></a></p>'], '']);
+      //assert.deepStrictEqual(inspect(parser('!http://host#\\ a')), [['<p>!<a class="url" href="http://host#" target="_blank">http://host#</a> a</p>'], '']);
+      //assert.deepStrictEqual(inspect(parser(' !http://host#\\')), [['<p> !<a class="url" href="http://host#" target="_blank">http://host#</a></p>'], '']);
       assert.deepStrictEqual(inspect(parser('\ta')), [['<p>\ta</p>'], '']);
     });
 

package/src/parser/block/table.ts

@@ -1,6 +1,6 @@
 import { TableParser } from '../block';
-import { union, sequence, some, creation, block, line, validate, focus, rewrite, surround, open, fallback, lazy, fmap } from '../../combinator';
-import { inline } from '../inline';
+import { union, sequence, some, creation, block, line, validate, focus, rewrite, surround, open, close, trimStart, fallback, lazy, fmap } from '../../combinator';
+import { inline, media, medialink, shortmedia } from '../inline';
 import { contentline } from '../source';
 import { trimBlankStart, trimNodeEnd } from '../visibility';
 import { duffReduce } from 'spica/duff';
@@ -49,7 +49,12 @@ const align: AlignParser = creation(1, false, fmap(open(
 
 const cell: CellParser = surround(
   /^\|\s*(?=\S)/,
-  trimBlankStart(some(union([inline]), /^\|/, [[/^[|\\]?\s*$/, 9]])),
+  trimStart(union([
+    close(medialink, /^\s*(?=\||$)/),
+    close(media, /^\s*(?=\||$)/),
+    close(shortmedia, /^\s*(?=\||$)/),
+    trimBlankStart(some(inline, /^\|/, [[/^[|\\]?\s*$/, 9]])),
+  ])),
   /^[^|]*/, true);
 
 const head: CellParser.HeadParser = creation(1, false, fmap(

package/src/parser/block/ulist.ts

@@ -1,18 +1,18 @@
 import { UListParser } from '../block';
-import { union, inits, subsequence, some, creation, state, block, line, validate, indent, focus, open, close, trim, fallback, lazy, fmap } from '../../combinator';
-import { olist_, invalid } from './olist';
+import { Parser } from '../../combinator/data/parser';
+import { union, inits, subsequence, some, creation, block, line, validate, indent, focus, rewrite, open, close, trim, fallback, lazy, fmap } from '../../combinator';
+import { olist_ } from './olist';
 import { ilist_ } from './ilist';
 import { inline, indexer, indexee } from '../inline';
 import { index } from '../inline/extension/index';
-import { State } from '../context';
+import { contentline } from '../source';
 import { visualize, trimBlank } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const ulist: UListParser = lazy(() => block(validate(
   /^-(?=[^\S\n]|\n[^\S\n]*\S)/,
-  state(State.media,
-  ulist_))));
+  ulist_)));
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
   /^-(?=$|\s)/,
@@ -38,6 +38,18 @@ export const checkbox = creation(1, false, focus(
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
   ], '']));
 
+export const invalid = rewrite(
+  inits([contentline, indent<Parser<string>>(({ source }) => [[source], ''])]),
+  ({ source }) => [[
+    '',
+    html('span', {
+      class: 'invalid',
+      'data-invalid-syntax': 'list',
+      'data-invalid-type': 'syntax',
+      'data-invalid-message': 'Fix the indent or the head of the list item',
+    }, source.replace('\n', ''))
+  ], '']);
+
 export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | string)[] {
   return ns.length === 1
       && typeof ns[0] === 'object'

package/src/parser/block.ts

@@ -13,6 +13,7 @@ import { mathblock } from './block/mathblock';
 import { extension } from './block/extension';
 import { sidefence } from './block/sidefence';
 import { blockquote } from './block/blockquote';
+import { mediablock } from './block/mediablock';
 import { reply } from './block/reply';
 import { paragraph } from './block/paragraph';
 import { rnd0Z } from 'spica/random';
@@ -31,6 +32,7 @@ export import MathBlockParser = BlockParser.MathBlockParser;
 export import ExtensionParser = BlockParser.ExtensionParser;
 export import SidefenceParser = BlockParser.SidefenceParser;
 export import BlockquoteParser = BlockParser.BlockquoteParser;
+export import MediaBlockParser = BlockParser.MediaBlockParser;
 export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
@@ -50,6 +52,7 @@ export const block: BlockParser = creation(1, false, error(
     extension,
     sidefence,
     blockquote,
+    mediablock,
     reply,
     paragraph
   ]))));

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

@@ -7,9 +7,9 @@ describe('Unit: parser/inline/bracket', () => {
     const parser = (source: string) => some(bracket)({ source, context: {} });
 
     it('(', () => {
-      assert.deepStrictEqual(inspect(parser('(')), [['', '('], '']);
+      assert.deepStrictEqual(inspect(parser('(')), [['('], '']);
       assert.deepStrictEqual(inspect(parser('()')), [['<span class="paren">()</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('(a')), [['', '(', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('(a')), [['(', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('(0)')), [['(', '0', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(1)')), [['(', '1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(10)')), [['(', '10', ')'], '']);
@@ -39,7 +39,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(ABBR, ABBR)')), [['(', 'ABBR, ABBR', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(\\a)')), [['<span class="paren">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(==)')), [['<span class="paren">(==)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('($)$')), [['', '(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('($)$')), [['(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(')')), undefined);
       assert.deepStrictEqual(inspect(parser('（１，２）')), [['（', '１，２', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（０－１）')), [['（', '０－１', '）'], '']);
@@ -51,12 +51,12 @@ describe('Unit: parser/inline/bracket', () => {
     });
 
     it('[', () => {
-      assert.deepStrictEqual(inspect(parser('[')), [['', '['], '']);
+      assert.deepStrictEqual(inspect(parser('[')), [['['], '']);
       assert.deepStrictEqual(inspect(parser('[]')), [['[', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[a')), [['', '[', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('[a')), [['[', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[a]')), [['[', 'a', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[==]')), [['[', '==', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[$]$')), [['', '[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[$]$')), [['[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(']')), undefined);
     });
 
@@ -74,8 +74,8 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('""')), [['"', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"a')), [['"', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('"a"')), [['"', 'a', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"(")"')), [['"', '', '(', '"'], ')"']);
-      assert.deepStrictEqual(inspect(parser('"(("')), [['"', '', '(', '', '(', '"'], '']);
+      assert.deepStrictEqual(inspect(parser('"(")"')), [['"', '(', '"'], ')"']);
+      assert.deepStrictEqual(inspect(parser('"(("')), [['"', '(', '(', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"')), [['"', '<span class="paren">(")</span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\\n)"')), [['"', '<span class="paren">(<br>)</span>', '"'], '']);

package/src/parser/inline/bracket.ts

@@ -12,14 +12,14 @@ export const bracket: BracketParser = lazy(() => union([
   surround(str('('), syntax(Syntax.none, 2, 1, State.none, str(index)), str(')')),
   surround(str('('), syntax(Syntax.bracket, 2, 1, State.none, some(inline, ')', [[')', 2]])), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
+    ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('（'), syntax(Syntax.none, 2, 1, State.none, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
   surround(str('（'), syntax(Syntax.bracket, 2, 1, State.none, some(inline, '）', [['）', 2]])), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), syntax(Syntax.bracket, 2, 1, State.none, some(inline, ']', [[']', 2]])), str(']'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
+    ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), syntax(Syntax.bracket, 2, 1, State.none, some(inline, '}', [['}', 2]])), str('}'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),

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

@@ -1,14 +1,12 @@
 import { ExtensionParser } from '../../inline';
-import { union, creation, state, focus, surround } from '../../../combinator';
+import { union, creation, focus, surround } from '../../../combinator';
 import { signature } from './index';
-import { State } from '../../context';
 import { html } from 'typed-dom/dom';
 
 export const indexer: ExtensionParser.IndexerParser = surround(
   /^\s+\[(?=\|\S)/,
-  state(State.index, false,
   union([
     signature,
     creation(focus(/^\|(?=\])/, () => [[html('span', { class: 'indexer', 'data-index': '' })], ''])),
-  ])),
+  ]),
   /^\]\s*$/);

package/src/parser/inline/html.ts

@@ -41,8 +41,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         ([as, bs = [], cs], rest) =>
           [[elem(tag, as, bs, cs)], rest],
         ([as, bs = []], rest) =>
-          [[elem(tag, as, bs, [])], rest]),
-    ([, tag]) => TAGS.indexOf(tag), [])),
+          [[elem(tag, as, bs, [])], rest]))),
   match(
     /^<([a-z]+)(?=[^\S\n]|>)/i,
     memoize(

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

@@ -16,12 +16,12 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[% ')), [['[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% \n a')), [['[%', '<br>', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[%%]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[% [%')), [['[%', ' ', '', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% [%')), [['[%', ' ', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% ')), [['[%', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a')), [['[%', ' ', '[%', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a %]')), [['[%', ' ', '<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a[%')), [['[%', ' ', 'a', '', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [%')), [['[%', ' ', 'a', ' ', '', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a[%')), [['[%', ' ', 'a', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [%')), [['[%', ' ', 'a', ' ', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [% ')), [['[%', ' ', 'a', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [% b')), [['[%', ' ', 'a', ' ', '[%', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [%% b')), [['[%', ' ', 'a', ' ', '[%%', ' ', 'b'], '']);

package/src/parser/inline/remark.ts

@@ -22,4 +22,4 @@ export const remark: RemarkParser = lazy(() => validate('[%', syntax(Syntax.none
         ]),
       ], rest],
       ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  ([, fence]) => fence.length, [])))));
+  ([, fence]) => fence.length, {})))));

package/src/parser/inline.test.ts

@@ -134,7 +134,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('{a}')), [['<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('{{a}}')), [['<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('\r!{}')), [['!', '{', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{a}')), [['<a href="a" target="_blank"><img class="media" data-src="a" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('\r!{a}')), [['!', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('\r!{{a}}')), [['!', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('\r!{{{a}}}')), [['!', '<span class="template">{{{a}}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('\r!!{a}')), [['!', '!', '<a class="url" href="a">a</a>'], '']);
@@ -143,35 +143,35 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('${{{a}}}')), [['$', '<span class="template">{{{a}}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney Micro$oft')), [['Di', '$', 'ney', ' ', 'Micro', '$', 'oft'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney, Micro$oft')), [['Di', '$', 'ney', ',', ' ', 'Micro', '$', 'oft'], '']);
-      assert.deepStrictEqual(inspect(parser('(((a))')), [['', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((((a))')), [['', '(', '', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('(((a))')), [['(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((((a))')), [['(', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((${))}$')), [['', '(', '', '(', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('((${))}$')), [['(', '(', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['', '[', '<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['', '[', '', '[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[$-1]]]')), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><span><a class="url" href="a">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a class="link" href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a class="link" href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['', '[', '', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['[', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[==a==]{b}')), [['<a class="link" href="b">==a==</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a class="link" href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['[', '[', '[', '[', '[', '[', '[', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a class="url" href="http://host" target="_blank">http://host</a>', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('[~http://host')), [['', '[', '~', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[~a@b')), [['', '[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[~http://host')), [['[', '~', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[~a@b')), [['[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[~~a~~]')), [['[', '<del>a</del>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[^http://host')), [['[^', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a++b\nc++]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<ins>b<br>c</ins>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[++a\nb++]{/}')), [['[', '<ins>a<br>b</ins>', ']', '<a class="url" href="/">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[++a\nb]++')), [['[', '++', 'a', '<br>', 'b', ']', '++'], '']);
-      assert.deepStrictEqual(inspect(parser('[++[a\nb++]')), [['', '[', '++', '[', 'a', '<br>', 'b', '++', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[++[a\nb++]')), [['[', '++', '[', 'a', '<br>', 'b', '++', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[[++a\nb++]]')), [['[', '[', '<ins>a<br>b</ins>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
@@ -242,7 +242,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a*#b')), [['<em>a</em>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a]]#b')), [['<sup class="reference"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a')), [['', '[', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('|#a')), [['|', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' #a')), [[' ', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
     });

package/src/parser/inline.ts

@@ -7,7 +7,7 @@ import { remark } from './inline/remark';
 import { math } from './inline/math';
 import { extension } from './inline/extension';
 import { ruby } from './inline/ruby';
-import { textlink, linemedialink } from './inline/link';
+import { textlink } from './inline/link';
 import { html } from './inline/html';
 import { insertion } from './inline/insertion';
 import { deletion } from './inline/deletion';
@@ -16,9 +16,7 @@ import { emstrong } from './inline/emstrong';
 import { emphasis } from './inline/emphasis';
 import { strong } from './inline/strong';
 import { code } from './inline/code';
-import { linemedia } from './inline/media';
 import { htmlentity } from './inline/htmlentity';
-import { lineshortmedia } from './inline/shortmedia';
 import { autolink } from './inline/autolink';
 import { bracket } from './inline/bracket';
 import { text } from './source';
@@ -56,8 +54,6 @@ export const inline: InlineParser = lazy(() => union([
   extension,
   ruby,
   textlink,
-  linemedialink,
-  linemedia,
   html,
   insertion,
   deletion,
@@ -67,7 +63,6 @@ export const inline: InlineParser = lazy(() => union([
   emphasis,
   code,
   htmlentity,
-  lineshortmedia,
   autolink,
   bracket,
   text
@@ -75,5 +70,6 @@ export const inline: InlineParser = lazy(() => union([
 
 export { indexee } from './inline/extension/indexee';
 export { indexer } from './inline/extension/indexer';
+export { medialink } from './inline/link';
 export { media } from './inline/media';
 export { shortmedia } from './inline/shortmedia';

package/src/parser/processor/figure.ts

@@ -127,7 +127,6 @@ export function* figure(
     }
     yield ref;
   }
-  return;
 }
 
 const messages = {

package/src/parser/processor/note.ts

@@ -14,7 +14,6 @@ export function* note(
 ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
   yield* annotation(target, notes?.annotations, opts, bottom);
   yield* reference(target, notes?.references, opts, bottom);
-  return;
 }
 
 export const annotation = build('annotation', n => `*${n}`, 'h1, h2, h3, h4, h5, h6, aside.aside, hr');
@@ -180,7 +179,6 @@ function build(
         el.remove();
       }
     }
-    return;
   }
 
   function* proc(defs: Map<string, HTMLLIElement>, note: HTMLOListElement): Generator<HTMLLIElement | undefined, undefined, undefined> {
@@ -213,7 +211,6 @@ function build(
       --length;
       assert(children.length === length);
     }
-    return;
   }
 }
 

package/src/parser/visibility.ts

@@ -3,7 +3,6 @@ import { Parser, Input, eval } from '../combinator/data/parser';
 import { union, some, verify, convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
 import { linebreak, unescsource } from './source';
-import { State } from './context';
 import { invisibleHTMLEntityNames } from './api/normalize';
 import { reduce } from 'spica/memoize';
 import { push } from 'spica/array';
@@ -23,13 +22,12 @@ export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Pa
   return union([
     convert(
       source => source.replace(blank.line, line => line.replace(/[\\&<]/g, '\x1B$&')),
-      verify(parser, (ns, rest, context) => !rest && hasVisible(ns, context))),
+      verify(parser, (ns, rest) => !rest && hasVisible(ns))),
     some(union([linebreak, unescsource])),
   ]);
 }
 function hasVisible(
   nodes: readonly (HTMLElement | string)[],
-  { state = 0 }: MarkdownParser.Context = {},
 ): boolean {
   for (let i = 0; i < nodes.length; ++i) {
     const node = nodes[i];
@@ -38,8 +36,8 @@ function hasVisible(
     }
     else {
       if (node.innerText.trimStart()) return true;
-      if (state & State.media ^ State.media &&
-          (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
+      //if (state & State.media ^ State.media &&
+      //    (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
     }
   }
   return false;

package/src/renderer/render/media/image.ts

@@ -15,6 +15,6 @@ export function image(source: HTMLImageElement, url: URL, cache?: Dict<string, H
     source.cloneNode(true),
     Object.fromEntries([...source.attributes]
       .filter(attr => !['class', 'data-type', 'data-src', 'src', 'loading'].includes(attr.name))
-      .map(attr => [attr.name, null]))));
+      .map(attr => [attr.name, attr.name === 'alt' ? '' : null]))));
   return source;
 }