securemark 0.288.0 → 0.288.2

package/markdown.d.ts

@@ -1112,12 +1112,6 @@ export namespace MarkdownParser {
       // ""
       Inline<'bracket'>,
       Parser<HTMLElement | string, Context, [
-        SourceParser.StrParser,
-        InlineParser,
-        SourceParser.StrParser,
-        InlineParser,
-        InlineParser,
-        InlineParser,
         InlineParser,
         InlineParser,
         InlineParser,
@@ -1251,7 +1245,7 @@ export namespace MarkdownParser {
     export interface TextParser extends
       // abc
       Source<'text'>,
-      Parser<string | HTMLBRElement | HTMLSpanElement, Context, []> {
+      Parser<string | HTMLBRElement, Context, []> {
     }
     export interface TxtParser extends
       // abc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.288.0",
+  "version": "0.288.2",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

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

@@ -94,6 +94,11 @@ export function surround<T>(
         backtracks[source.length + offset - 1] |= 1 << (backtrack >>> 2) + shift;
       }
     }
+    context.recent = [
+      lmr_.slice(0, lmr_.length - mr_.length),
+      mr_.slice(0, mr_.length - r_.length),
+      r_.slice(0, r_.length - rest.length),
+    ];
     return rr
       ? f
         ? f([rl, rm!, rr], rest, context)

package/src/combinator/data/parser/context/delimiter.ts

@@ -1,4 +1,4 @@
-import { memoize, reduce } from 'spica/memoize';
+import { memoize } from 'spica/memoize';
 
 interface Delimiter {
   readonly index: number;
@@ -27,7 +27,7 @@ export class Delimiters {
         case 'string':
           return source => source.slice(0, pattern.length) === pattern || undefined;
         case 'object':
-          return reduce(source => pattern.test(source) || undefined);
+          return source => pattern.test(source) || undefined;
       }
     },
     this.signature);

package/src/combinator/data/parser.ts

@@ -21,6 +21,7 @@ export interface Ctx {
   state?: number;
   backtracks?: Record<number, number>;
   backtrack?: number;
+  recent?: string[];
 }
 export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;
 export type SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, Ctx, infer D> ? D : never;

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

@@ -350,7 +350,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack', function () {
       this.timeout(5000);
-      const str = `${'.'.repeat(0 + 0)}((${'['.repeat(13)}{{http://[[[${'.'.repeat(8326)}`;
+      const str = `${'.'.repeat(7 + 0)}((${'['.repeat(13)}{{http://[[[${'.'.repeat(8328)}`;
       assert.deepStrictEqual(
         [...parse(str).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [`<p>${str}</p>`]);
@@ -358,7 +358,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack error', function () {
       this.timeout(5000);
-      const str = `${'.'.repeat(0 + 1)}((${'['.repeat(13)}{{http://[[[${'.'.repeat(8326)}`;
+      const str = `${'.'.repeat(7 + 1)}((${'['.repeat(13)}{{http://[[[${'.'.repeat(8328)}`;
       assert.deepStrictEqual(
         [...parse(str).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [

package/src/parser/block/codeblock.ts

@@ -2,6 +2,7 @@ import { CodeBlockParser } from '../block';
 import { eval } from '../../combinator/data/parser';
 import { block, validate, fence, clear, fmap } from '../../combinator';
 import { autolink } from '../autolink';
+import { invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const opener = /^(`{3,})(?!`)([^\n]*)(?:$|\n)/;
@@ -51,12 +52,14 @@ export const codeblock: CodeBlockParser = block(validate('```', fmap(
     if (!closer || overflow || params.invalid) return [html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-syntax': 'codeblock',
-      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
-      'data-invalid-message':
-        !closer ? `Missing the closing delimiter "${delim}"` :
-        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
-        params.invalid,
+      ...invalid(
+        'codeblock',
+        !closer || overflow ? 'fence' : 'argument',
+        !closer
+          ? `Missing the closing delimiter "${delim}"`
+          : overflow
+            ? `Invalid trailing line after the closing delimiter "${delim}"`
+            : params.invalid!),
     }, `${opener}${body}${overflow || closer}`)];
     const el = html('pre',
       {

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

@@ -2,6 +2,7 @@ import { ExtensionParser } from '../../block';
 import { Recursion } from '../../context';
 import { recursion, block, validate, fence, fmap } from '../../../combinator';
 import { identity } from '../../inline/extension/indexee';
+import { invalid } from '../../util';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
@@ -12,12 +13,12 @@ export const aside: ExtensionParser.AsideParser = recursion(Recursion.block, blo
     if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-syntax': 'aside',
-      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
-      'data-invalid-message':
+      ...invalid(
+        'aside',
+        !closer || overflow ? 'fence' : 'argument',
         !closer ? `Missing the closing delimiter "${delim}"` :
-        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
-        'Invalid argument',
+          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+            'Invalid argument'),
     }, `${opener}${body}${overflow || closer}`)];
     const references = html('ol', { class: 'references' });
     const document = parse(body.slice(0, -1), {
@@ -31,9 +32,7 @@ export const aside: ExtensionParser.AsideParser = recursion(Recursion.block, blo
     if (!heading) return [html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-syntax': 'aside',
-      'data-invalid-type': 'content',
-      'data-invalid-message': 'Missing the title at the first line',
+      ...invalid('aside', 'content', 'Missing the title at the first line'),
     }, `${opener}${body}${closer}`)];
     assert(identity('index', context.id, heading));
     return [

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

@@ -3,6 +3,7 @@ import { Recursion } from '../../context';
 import { eval } from '../../../combinator/data/parser';
 import { recursion, block, validate, fence, fmap } from '../../../combinator';
 import { mathblock } from '../mathblock';
+import { invalid } from '../../util';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
@@ -15,12 +16,12 @@ export const example: ExtensionParser.ExampleParser = recursion(Recursion.block,
     if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-syntax': 'example',
-      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
-      'data-invalid-message':
+      ...invalid(
+        'example',
+        !closer || overflow ? 'fence' : 'argument',
         !closer ? `Missing the closing delimiter "${delim}"` :
-        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
-        'Invalid argument',
+          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+            'Invalid argument'),
     }, `${opener}${body}${overflow || closer}`)];
     switch (type) {
       case 'markdown': {
@@ -53,9 +54,7 @@ export const example: ExtensionParser.ExampleParser = recursion(Recursion.block,
           html('pre', {
             class: 'invalid',
             translate: 'no',
-            'data-invalid-syntax': 'example',
-            'data-invalid-type': 'type',
-            'data-invalid-message': 'Invalid example type',
+            ...invalid('example', 'type', 'Invalid example type'),
           }, `${opener}${body}${closer}`),
         ];
     }

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

@@ -13,6 +13,7 @@ import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
 import { inline, media, shortmedia } from '../../inline';
 import { visualize, trimBlank } from '../../visibility';
+import { invalid } from '../../util';
 import { memoize } from 'spica/memoize';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -79,38 +80,40 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   ])),
   fmap(
     fence(/^(~{3,})(?:figure|\[?\$\S*)(?!\S)[^\n]*(?:$|\n)/, 300),
-    ([body, overflow, closer, opener, delim]: string[], _, context) => [
-      html('pre', {
-        class: 'invalid',
-        translate: 'no',
-        'data-invalid-syntax': 'figure',
-        ...
-        !closer && {
-          'data-invalid-type': 'fence',
-          'data-invalid-message': `Missing the closing delimiter "${delim}"`,
-        } ||
-        overflow && {
-          'data-invalid-type': 'fence',
-          'data-invalid-message': `Invalid trailing line after the closing delimiter "${delim}"`,
-        } ||
-        !seg_label({ source: opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context }) && {
-          'data-invalid-type': 'label',
-          'data-invalid-message': 'Invalid label',
-        } ||
-        /^~+(?:figure[^\S\n]+)?(\[?\$\S+)[^\S\n]+\S/.test(opener) && {
-          'data-invalid-type': 'argument',
-          'data-invalid-message': 'Invalid argument',
-        } ||
-        {
-          'data-invalid-type': 'content',
-          'data-invalid-message': 'Invalid content',
-        },
-      }, `${opener}${body}${overflow || closer}`),
-    ])));
+    ([body, overflow, closer, opener, delim]: string[], _, context) => {
+      const violation =
+        !closer && [
+          'fence',
+          `Missing the closing delimiter "${delim}"`,
+        ] ||
+        overflow && [
+          'fence',
+          `Invalid trailing line after the closing delimiter "${delim}"`,
+        ] ||
+        !seg_label({ source: opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context }) && [
+          'label',
+          'Invalid label',
+        ] ||
+        /^~+(?:figure[^\S\n]+)?(\[?\$\S+)[^\S\n]+\S/.test(opener) && [
+          'argument',
+          'Invalid argument',
+        ] ||
+        [
+          'content',
+          'Invalid content',
+        ];
+      return [
+        html('pre', {
+          class: 'invalid',
+          translate: 'no',
+          ...invalid('figure', violation[0], violation[1]),
+        }, `${opener}${body}${overflow || closer}`),
+      ];
+    })));
 
 function attributes(label: string, param: string, content: HTMLElement, caption: readonly HTMLElement[]): Record<string, string | undefined> {
   const group = label.split('-', 1)[0];
-  let type: string = content.className.split(/\s/)[0];
+  let type = content.className.split(/\s/)[0];
   switch (type || content.tagName) {
     case 'UL':
     case 'OL':
@@ -135,57 +138,57 @@ function attributes(label: string, param: string, content: HTMLElement, caption:
     default:
       assert(false);
   }
-  const invalid =
-    param.trimStart() !== '' && {
-      'data-invalid-type': 'argument',
-      'data-invalid-message': 'Invalid argument',
-    } ||
-    /^[^-]+-(?:[0-9]+\.)*0$/.test(label) && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': 'The last part of the fixed label numbers must not be 0',
-    } ||
-    group === '$' && (type !== 'math' || caption.length > 0) && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"$" label group must be used to math formulas with no caption',
-    } ||
-    type === 'media' && {} ||
-    ['fig', 'figure'].includes(group) && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"fig" and "figure" label groups must be used to media',
-    } ||
-    group === 'table' && type !== group && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"table" label group must be used to tables',
-    } ||
-    group === 'list' && type !== group && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"list" label group must be used to lists',
-    } ||
-    group === 'quote' && type !== group && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"quote" label group must be used to blockquotes',
-    } ||
-    group === 'text' && type !== group && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"text" label group must be used to codeblocks with no language',
-    } ||
-    group === 'code' && type !== group && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"code" label group must be used to codeblocks with any language',
-    } ||
-    group === 'example' && type !== group && {
-      'data-invalid-type': 'label',
-      'data-invalid-message': '"example" label group must be used to examples',
-    } ||
+  const violation =
+    param.trimStart() !== '' && [
+      'argument',
+      'Invalid argument',
+    ] ||
+    /^[^-]+-(?:[0-9]+\.)*0$/.test(label) && [
+      'label',
+      'The last part of the fixed label numbers must not be 0',
+    ] ||
+    group === '$' && (type !== 'math' || caption.length > 0) && [
+      'label',
+      '"$" label group must be used to math formulas with no caption',
+    ] ||
+    type === 'media' && [
+    ] ||
+    ['fig', 'figure'].includes(group) && [
+      'label',
+      '"fig" and "figure" label groups must be used to media',
+    ] ||
+    group === 'table' && type !== group && [
+      'label',
+      '"table" label group must be used to tables',
+    ] ||
+    group === 'list' && type !== group && [
+      'label',
+      '"list" label group must be used to lists',
+    ] ||
+    group === 'quote' && type !== group && [
+      'label',
+      '"quote" label group must be used to blockquotes',
+    ] ||
+    group === 'text' && type !== group && [
+      'label',
+      '"text" label group must be used to codeblocks with no language',
+    ] ||
+    group === 'code' && type !== group && [
+      'label',
+      '"code" label group must be used to codeblocks with any language',
+    ] ||
+    group === 'example' && type !== group && [
+      'label',
+      '"example" label group must be used to examples',
+    ] ||
     undefined;
   return {
     'data-type': type,
     'data-label': label,
     'data-group': group,
-    ...invalid?.['data-invalid-type'] && {
+    ...violation?.[0] && {
       class: 'invalid',
-      'data-invalid-syntax': 'figure',
-      ...invalid,
+      ...invalid('figure', violation[0], violation[1]),
     },
   };
 }

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

@@ -13,6 +13,7 @@ import { sidefence } from '../sidefence';
 import { blockquote } from '../blockquote';
 import { mediablock } from '../mediablock';
 import { paragraph } from '../paragraph';
+import { invalid } from '../../util';
 import { unshift, push } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
@@ -25,12 +26,12 @@ export const message: MessageParser = block(validate('~~~', fmap(
     if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-syntax': 'message',
-      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
-      'data-invalid-message':
+      ...invalid(
+        'message',
+        !closer || overflow ? 'fence' : 'argument',
         !closer ? `Missing the closing delimiter "${delim}"` :
-        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
-        'Invalid argument',
+          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+            'Invalid argument'),
     }, `${opener}${body}${overflow || closer}`)];
     switch (type) {
       case 'note':
@@ -41,9 +42,7 @@ export const message: MessageParser = block(validate('~~~', fmap(
         return [html('pre', {
           class: 'invalid',
           translate: 'no',
-          'data-invalid-syntax': 'message',
-          'data-invalid-type': 'type',
-          'data-invalid-message': 'Invalid message type',
+          ...invalid('message', 'type', 'Invalid message type'),
         }, `${opener}${body}${closer}`)];
     }
     return [

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

@@ -1,5 +1,6 @@
 import { ExtensionParser } from '../../block';
 import { block, validate, fence, clear, fmap } from '../../../combinator';
+import { invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
 const opener = /^(~{3,})(?!~)[^\n]*(?:$|\n)/;
@@ -16,9 +17,11 @@ export const placeholder: ExtensionParser.PlaceholderParser = block(validate('~~
     html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-message':
+      ...invalid(
+        'extension',
+        'fence',
         !closer ? `Missing the closing delimiter "${delim}"` :
-        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
-        'Invalid argument',
+          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+            'Invalid argument'),
     }, `${opener}${body}${overflow || closer}`),
   ])));

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

@@ -4,7 +4,7 @@ import { Tree, eval } from '../../../combinator/data/parser';
 import { union, subsequence, inits, some, 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 { lineable } from '../../util';
+import { lineable, invalid } from '../../util';
 import { visualize, trimBlank, trimBlankEnd } from '../../visibility';
 import { unshift, splice } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -29,12 +29,12 @@ export const table: TableParser = block(validate('~~~', fmap(
     if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
-      'data-invalid-syntax': 'table',
-      'data-invalid-type': !closer || overflow ? 'fence' : 'argument',
-      'data-invalid-message':
+      ...invalid(
+        'table',
+        !closer || overflow ? 'fence' : 'argument',
         !closer ? `Missing the closing delimiter "${delim}"` :
-        overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
-        'Invalid argument',
+          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+            'Invalid argument'),
     }, `${opener}${body}${overflow || closer}`)];
     switch (type) {
       case 'grid':
@@ -45,9 +45,7 @@ export const table: TableParser = block(validate('~~~', fmap(
         return [html('pre', {
           class: 'invalid',
           translate: 'no',
-          'data-invalid-syntax': 'table',
-          'data-invalid-type': 'argument',
-          'data-invalid-message': 'Invalid table type',
+          ...invalid('table', 'argument', 'Invalid table type'),
         }, `${opener}${body}${closer}`)];
     }
   })));
@@ -140,21 +138,12 @@ function attributes(source: string): Record<string, string | undefined> {
     class: valid ? highlight && 'highlight' : 'invalid',
     rowspan,
     colspan,
-    ...
-    !validH && {
-      'data-invalid-syntax': 'table',
-      'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Too much highlight level',
-    } ||
-    !validE && {
-      'data-invalid-syntax': 'table',
-      'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Extensible cells are only head cells',
-    } ||
-    {
-      'data-highlight-level': level > 1 ? `${level}` : undefined,
-      'data-highlight-extension': extension,
-    },
+    ...!validH && invalid('table', 'syntax', 'Too much highlight level')
+    || !validE && invalid('table', 'syntax', 'Extensible cells are only head cells')
+    || {
+        'data-highlight-level': level > 1 ? `${level}` : undefined,
+        'data-highlight-extension': extension,
+      },
   };
 }
 

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

@@ -69,7 +69,7 @@ describe('Unit: parser/block/heading', () => {
       assert.deepStrictEqual(inspect(parser('# a [|b ]')), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [|b  ]')), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [|b c]')), [['<h1 id="index::b_c">a<span class="indexer" data-index="b_c"></span></h1>'], '']);
-      assert.deepStrictEqual(inspect(parser('# a [|*b*`c`${d}$]')), [['<h1 id="index::b`c`${d}$">a<span class="indexer" data-index="b`c`${d}$"></span></h1>'], '']);
+      assert.deepStrictEqual(inspect(parser('# a [|*b*`c`${d}$]')), [['<h1 id="index::*b*`c`${d}$">a<span class="indexer" data-index="*b*`c`${d}$"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [|@a]')), [['<h1 id="index::@a">a<span class="indexer" data-index="@a"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [|http://host]')), [['<h1 id="index::http://host">a<span class="indexer" data-index="http://host"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a [|!http://host]')), [['<h1 id="index::!http://host">a<span class="indexer" data-index="!http://host"></span></h1>'], '']);

package/src/parser/block/heading.ts

@@ -4,6 +4,7 @@ import { union, some, state, block, line, validate, focus, rewrite, open, fmap }
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { str } from '../source';
 import { visualize, trimBlank } from '../visibility';
+import { invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
@@ -27,8 +28,6 @@ export const heading: HeadingParser = block(rewrite(segment,
       ? html(`h${h.length as 1}`, { 'data-index': dataindex(ns) }, defrag(ns))
       : html(`h6`, {
           class: 'invalid',
-          'data-invalid-syntax': 'heading',
-          'data-invalid-type': 'syntax',
-          'data-invalid-message': 'Heading level must be up to 6',
+          ...invalid('heading', 'syntax', 'Heading level must be up to 6'),
         }, defrag(ns))
   ]))))));

package/src/parser/block/ilist.ts

@@ -1,11 +1,13 @@
 import { IListParser } from '../block';
+import { Parser } from '../../combinator/data/parser';
 import { Recursion } from '../context';
-import { union, inits, some, recursion, block, line, validate, indent, open, trim, fallback, lazy, fmap } from '../../combinator';
-import { ulist_, invalid, fillFirstLine } from './ulist';
+import { union, inits, some, recursion, block, line, validate, indent, rewrite, open, trim, fallback, lazy, fmap } from '../../combinator';
+import { ulist_, fillFirstLine } from './ulist';
 import { olist_ } from './olist';
 import { inline } from '../inline';
-import { lineable } from '../util';
+import { contentline } from '../source';
 import { visualize, trimBlank } from '../visibility';
+import { lineable, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ilist: IListParser = lazy(() => block(validate(
@@ -20,14 +22,22 @@ export const ilist_: IListParser = lazy(() => block(fmap(validate(
         line(open(/^[-+*](?:$|\s)/, trim(visualize(trimBlank(lineable(some(inline))))), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
-      invalid),
+      ilistitem),
       ns => [html('li', defrag(fillFirstLine(ns)))]),
   ])))),
   es => [
     html('ul', {
       class: 'invalid',
-      'data-invalid-syntax': 'list',
-      'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Use "-" instead of "+" or "*"',
+      ...invalid('list', 'syntax', 'Use "-" instead of "+" or "*"'),
     }, es),
   ])));
+
+export const ilistitem = rewrite(
+  inits([contentline, indent<Parser<string>>(({ source }) => [[source], ''])]),
+  ({ source }) => [[
+    '',
+    html('span', {
+      class: 'invalid',
+      ...invalid('list', 'syntax', 'Fix the indent or the head of the list item'),
+    }, source.replace('\n', ''))
+  ], '']);

package/src/parser/block/mathblock.ts

@@ -1,5 +1,6 @@
 import { MathBlockParser } from '../block';
 import { block, validate, fence, clear, fmap } from '../../combinator';
+import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 const opener = /^(\${2,})(?!\$)([^\n]*)(?:$|\n)/;
@@ -20,11 +21,12 @@ export const mathblock: MathBlockParser = block(validate('$$', fmap(
       : html('pre', {
           class: 'invalid',
           translate: 'no',
-          'data-invalid-syntax': 'mathblock',
-          'data-invalid-type': delim.length > 2 ? 'syntax' : !closer || overflow ? 'fence' : 'argument',
-          'data-invalid-message': delim.length > 2 ? 'Invalid syntax' :
-             !closer ? `Missing the closing delimiter "${delim}"` :
-             overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
-             'Invalid argument',
+          ...invalid(
+            'mathblock',
+            delim.length > 2 ? 'syntax' : !closer || overflow ? 'fence' : 'argument',
+            delim.length > 2 ? 'Invalid syntax' :
+              !closer ? `Missing the closing delimiter "${delim}"` :
+                overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+                  'Invalid argument'),
         }, `${opener}${body}${overflow || closer}`),
   ])));

package/src/parser/block/mediablock.ts

@@ -1,6 +1,7 @@
 import { MediaBlockParser } from '../block';
 import { union, inits, some, block, line, validate, fallback, fmap } from '../../combinator';
 import { medialink, media, shortmedia } from '../inline';
+import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 export const mediablock: MediaBlockParser = block(validate(['[!', '!'], fmap(
@@ -14,13 +15,9 @@ export const mediablock: MediaBlockParser = block(validate(['[!', '!'], fmap(
       medialink,
       media,
       shortmedia,
-    ]), ({ source }) => [[html('div', [html('span', attrs, source.replace('\n', ''))])], '']))),
+    ]), ({ source }) => [[html('div', [html('span', {
+      class: 'invalid',
+      ...invalid('mediablock', 'syntax', 'Not media syntax'),
+    }, 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;