securemark 0.288.0 → 0.288.1

package/src/parser/block/sidefence.ts

@@ -3,6 +3,7 @@ import { Recursion } from '../context';
 import { union, some, recursion, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
+import { invalid } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
@@ -11,9 +12,7 @@ export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
   ([el]) => [
     define(el, {
       class: 'invalid',
-      'data-invalid-syntax': 'sidefence',
-      'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Reserved syntax',
+      ...invalid('sidefence', 'syntax', 'Reserved syntax'),
     }),
   ])));
 

package/src/parser/block/table.ts

@@ -3,6 +3,7 @@ import { union, sequence, some, block, line, validate, focus, rewrite, surround,
 import { inline, media, medialink, shortmedia } from '../inline';
 import { contentline } from '../source';
 import { trimBlank } from '../visibility';
+import { invalid } from '../util';
 import { duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
@@ -31,9 +32,7 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
   rewrite(contentline, ({ source }) => [[
     html('tr', {
       class: 'invalid',
-      'data-invalid-syntax': 'table-row',
-      'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Missing the start symbol of the table row',
+      ...invalid('table-row', 'syntax', 'Missing the start symbol of the table row'),
     }, [html('td', source.replace('\n', ''))])
   ], '']));
 

package/src/parser/block/ulist.ts

@@ -1,11 +1,9 @@
 import { UListParser } from '../block';
-import { Parser } from '../../combinator/data/parser';
 import { Recursion } from '../context';
-import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, rewrite, open, trim, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, trim, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
-import { ilist_ } from './ilist';
+import { ilist_, ilistitem } from './ilist';
 import { inline, indexer, indexee, dataindex } from '../inline';
-import { contentline } from '../source';
 import { lineable } from '../util';
 import { visualize, trimBlank } from '../visibility';
 import { unshift } from 'spica/array';
@@ -26,7 +24,7 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
         ]), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
-      invalid),
+      ilistitem),
       ns => [html('li', { 'data-index': dataindex(ns) }, defrag(fillFirstLine(ns)))])),
   ])))),
   es => [format(html('ul', es))])));
@@ -37,18 +35,6 @@ export const checkbox = focus(
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
   ], ''], false);
 
-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/header.ts

@@ -2,6 +2,7 @@ import { MarkdownParser } from '../../markdown';
 import { union, inits, some, block, line, validate, focus, rewrite, clear, convert, lazy, fmap } from '../combinator';
 import { segment } from './segment';
 import { str } from './source';
+import { invalid } from './util';
 import { normalize } from './api/normalize';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -31,9 +32,7 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
             html('pre', {
               class: 'invalid',
               translate: 'no',
-              'data-invalid-syntax': 'header',
-              'data-invalid-type': 'syntax',
-              'data-invalid-message': 'Invalid syntax',
+              ...invalid('header', 'syntax', 'Invalid syntax'),
             }, normalize(source)),
           ], ''],
         ]))),

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

@@ -4,6 +4,7 @@ import { union, some, recursion, precedence, surround, lazy } from '../../../com
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { tightStart } from '../../visibility';
+import { invalid } from '../../util';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -19,9 +20,7 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surroun
   ([, bs], rest) => [[
     html('span', {
       class: 'invalid',
-      'data-invalid-syntax': 'extension',
-      'data-invalid-type': 'syntax',
-      'data-invalid-message': `Invalid start symbol or linebreak`,
+      ...invalid('extension', 'syntax', `Invalid start symbol or linebreak`),
     }, defrag(bs)),
   ], rest],
   ([as, bs], rest) => [unshift(as, bs), rest], [3 | Backtrack.bracket]));

package/src/parser/inline/html.ts

@@ -4,6 +4,7 @@ import { union, subsequence, some, recursion, precedence, validate, focus, surro
 import { inline } from '../inline';
 import { str } from '../source';
 import { isLooseNodeStart, blankWith } from '../visibility';
+import { invalid } from '../util';
 import { memoize } from 'spica/memoize';
 import { Clock } from 'spica/clock';
 import { unshift, push, splice } from 'spica/array';
@@ -216,23 +217,20 @@ const TAGS = Object.freeze([
 function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: string[]): HTMLElement {
   assert(as.length > 0);
   assert(as[0][0] === '<' && as.at(-1)!.slice(-1) === '>');
-  if (!tags.includes(tag)) return invalid('tag', `Invalid HTML tag name "${tag}"`, as, bs, cs);
-  if (cs.length === 0) return invalid('tag', `Missing the closing HTML tag "</${tag}>"`, as, bs, cs);
-  if (bs.length === 0) return invalid('content', `Missing the content`, as, bs, cs);
-  if (!isLooseNodeStart(bs)) return invalid('content', `Missing the visible content in the same line`, as, bs, cs);
+  if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, as, bs, cs);
+  if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, as, bs, cs);
+  if (bs.length === 0) return ielem('content', `Missing the content`, as, bs, cs);
+  if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, as, bs, cs);
   const attrs = attributes('html', [], attrspecs[tag], as.slice(1, -1));
-  return 'data-invalid-syntax' in attrs
-    ? invalid('attribute', 'Invalid HTML attribute', as, bs, cs)
+  return /(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')
+    ? ielem('attribute', 'Invalid HTML attribute', as, bs, cs)
     : h(tag as 'span', attrs, defrag(bs));
 }
 
-function invalid(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
-  return h('span', {
-    class: 'invalid',
-    'data-invalid-syntax': 'html',
-    'data-invalid-type': type,
-    'data-invalid-message': message,
-  }, defrag(push(unshift(as, bs), cs)));
+function ielem(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
+  return h('span',
+    { class: 'invalid', ...invalid('html', type, message) },
+    defrag(push(unshift(as, bs), cs)));
 }
 
 const requiredAttributes = memoize(
@@ -249,7 +247,7 @@ export function attributes(
   assert(spec instanceof Object === false);
   assert(!spec?.['__proto__']);
   assert(!spec?.toString);
-  let invalid = false;
+  let invalidation = false;
   const attrs: Record<string, string | undefined> = {};
   for (let i = 0; i < params.length; ++i) {
     const param = params[i].trim();
@@ -257,20 +255,20 @@ export function attributes(
     const value = param !== name
       ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
       : undefined;
-    invalid ||= !spec || name in attrs;
+    invalidation ||= !spec || name in attrs;
     if (spec && name in spec && !spec[name]) continue;
-    spec?.[name]?.includes(value) || value !== undefined && spec?.[name]?.length === 0
+    spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined
       ? attrs[name] = value ?? ''
-      : invalid ||= !!spec;
+      : invalidation ||= !!spec;
     assert(!(name in {} && attrs.hasOwnProperty(name)));
     splice(params, i--, 1);
   }
-  invalid ||= !!spec && !requiredAttributes(spec).every(name => name in attrs);
-  if (invalid) {
-    attrs['class'] = (classes.includes('invalid') ? classes : unshift(classes, ['invalid'])).join(' ');
-    attrs['data-invalid-syntax'] = syntax;
-    attrs['data-invalid-type'] = 'argument';
-    attrs['data-invalid-message'] = 'Invalid argument';
+  invalidation ||= !!spec && !requiredAttributes(spec).every(name => name in attrs);
+  if (invalidation) {
+    attrs['class'] = classes.length === 0
+      ? 'invalid'
+      : `${classes.join(' ')}${classes.includes('invalid') ? '' : ' invalid'}`;
+    Object.assign(attrs, invalid(syntax, 'argument', 'Invalid argument'));
   }
   return attrs;
 }

package/src/parser/inline/htmlentity.ts

@@ -1,6 +1,7 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { Command } from '../context';
 import { union, validate, focus, fmap } from '../../combinator';
+import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 
@@ -14,9 +15,7 @@ export const htmlentity: HTMLEntityParser = fmap(
     text[0] === Command.Escape
       ? html('span', {
           class: 'invalid',
-          'data-invalid-syntax': 'htmlentity',
-          'data-invalid-type': 'syntax',
-          'data-invalid-message': 'Invalid HTML entity',
+          ...invalid('htmlentity', 'syntax', 'Invalid HTML entity'),
         }, text.slice(1))
       : text,
   ]);

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

@@ -64,6 +64,8 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{  }')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{   }')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[]{}}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[]{{}}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{{b}}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{b\nb}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{b\\\nb}')), undefined);
@@ -107,6 +109,8 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{  b }')), [['<a class="url" href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{  b  }')), [['<a class="url" href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{  b   }')), [['<a class="url" href="b">b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{"}')), [[`<a class="url" href="&quot;">"</a>`], '']);
+      assert.deepStrictEqual(inspect(parser('[]{"}"}')), [[`<a class="url" href="&quot;">"</a>`], '"}']);
       assert.deepStrictEqual(inspect(parser('[]{\\}')), [[`<a class="url" href="\\">\\</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\ }')), [[`<a class="url" href="\\">\\</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\b}')), [[`<a class="url" href="\\b">\\b</a>`], '']);

package/src/parser/inline/link.ts

@@ -6,7 +6,7 @@ import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { linebreak, unescsource, str } from '../source';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
-import { stringify } from '../util';
+import { invalid, stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { html, define, defrag } from 'typed-dom/dom';
 
@@ -94,7 +94,7 @@ function parse(
     content,
     uri,
     context.host?.origin || location.origin);
-  return el.className === 'invalid'
+  return el.classList.contains('invalid')
     ? el
     : define(el, attributes('link', [], optspec, params));
 }
@@ -166,9 +166,7 @@ function elem(
   return html('a',
     {
       class: 'invalid',
-      'data-invalid-syntax': 'link',
-      'data-invalid-type': type ??= 'argument',
-      'data-invalid-message': message ??= 'Invalid protocol',
+      ...invalid('link', type ??= 'argument', message ??= 'Invalid protocol'),
     },
     content.length === 0
       ? INSECURE_URI

package/src/parser/inline/math.ts

@@ -2,6 +2,7 @@ import { MathParser } from '../inline';
 import { Recursion } from '../context';
 import { union, some, recursion, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
 import { escsource, unescsource, str } from '../source';
+import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
@@ -25,9 +26,8 @@ export const math: MathParser = lazy(() => validate('$', rewrite(
         : {
             class: 'invalid',
             translate: 'no',
-            'data-invalid-syntax': 'math',
-            'data-invalid-type': 'content',
-            'data-invalid-message': `"${source.match(forbiddenCommand)![0]}" command is forbidden`,
+          ...invalid('math', 'content',
+            `"${source.match(forbiddenCommand)![0]}" command is forbidden`),
           },
       source)
   ], ''])));

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

@@ -7,10 +7,10 @@ describe('Unit: parser/inline/media', () => {
     const parser = (source: string) => some(media)({ source, context: {} });
 
     it('xss', () => {
-      assert.deepStrictEqual(inspect(parser('![]{javascript:alert}')), [['<img class="media invalid" data-src="javascript:alert" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{vbscript:alert}')), [['<img class="media invalid" data-src="vbscript:alert" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K}')), [['<img class="media invalid" data-src="data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{any:alert}')), [['<img class="media invalid" data-src="any:alert" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{javascript:alert}')), [['<img class="invalid" data-src="javascript:alert" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{vbscript:alert}')), [['<img class="invalid" data-src="vbscript:alert" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K}')), [['<img class="invalid" data-src="data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{any:alert}')), [['<img class="invalid" data-src="any:alert" alt="">'], '']);
       assert.deepStrictEqual(inspect(parser('![]{"}')), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\}')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![\\"]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="&quot;"></a>'], '']);
@@ -30,6 +30,8 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]{   }')), undefined);
       assert.deepStrictEqual(inspect(parser('![]]{/}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![]{}}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![]{{}}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{b}}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{b\nc}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{a\\\nc}')), undefined);
@@ -42,20 +44,20 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![\\ ]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![\\\n]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![&Tab;]{b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![&a;]{b}')), [['<img class="media invalid" data-src="b" alt="&amp;a;">'], '']);
+      assert.deepStrictEqual(inspect(parser('![&a;]{b}')), [['<img class="invalid" data-src="b" alt="&amp;a;">'], '']);
       assert.deepStrictEqual(inspect(parser('![[]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a\nb]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a\\\nb]{b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{ttp://host}')), [['<img class="media invalid" data-src="ttp://host" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{tel:1234567890}')), [['<img class="media invalid" data-src="tel:1234567890" alt="">'], '']);
-      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0%1]}')), [['<img class="media invalid" alt="">'], '']);
-      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0/96]}')), [['<img class="media invalid" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{.}')), [['<img class="media invalid" data-src="." alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{..}')), [['<img class="media invalid" data-src=".." alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{../}')), [['<img class="media invalid" data-src="../" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{/../b}')), [['<img class="media invalid" data-src="/../b" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{ttp://host}')), [['<img class="invalid" data-src="ttp://host" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{tel:1234567890}')), [['<img class="invalid" data-src="tel:1234567890" alt="">'], '']);
+      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0%1]}')), [['<img class="invalid" alt="">'], '']);
+      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0/96]}')), [['<img class="invalid" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{.}')), [['<img class="invalid" data-src="." alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{..}')), [['<img class="invalid" data-src=".." alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{../}')), [['<img class="invalid" data-src="../" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{/../b}')), [['<img class="invalid" data-src="/../b" alt="">'], '']);
       assert.deepStrictEqual(inspect(parser(' ![]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{/}')), undefined);
     });
@@ -69,6 +71,8 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]{  b }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{  b  }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{  b   }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{"}')), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{"}"}')), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt=""></a>'], '"}']);
       assert.deepStrictEqual(inspect(parser('![]{\\}')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\ }')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\b}')), [['<a href="\\b" target="_blank"><img class="media" data-src="\\b" alt=""></a>'], '']);

package/src/parser/inline/media.ts

@@ -5,7 +5,7 @@ import { unsafelink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, linebreak, str } from '../source';
-import { markInvalid } from '../util';
+import { invalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { push } from 'spica/array';
 import { html, define } from 'typed-dom/dom';
@@ -51,7 +51,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, false, vali
       || (cache = context.caches?.media?.get(url.href)?.cloneNode(true))
       || html('img', { class: 'media', 'data-src': url.source, alt: text });
     assert(!el.matches('.invalid'));
-    cache?.hasAttribute('alt') && cache?.setAttribute('alt', text);
+    cache?.hasAttribute('alt') && cache.setAttribute('alt', text);
     if (!sanitize(el, url, text)) return [[el], rest];
     assert(!el.matches('.invalid'));
     define(el, attributes('media', push([], el.classList), optspec, params));
@@ -98,19 +98,25 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
     case 'https:':
       assert(uri.host);
       if (/\/\.\.?(?:\/|$)/.test('/' + uri.source.slice(0, uri.source.search(/[?#]|$/)))) {
-        markInvalid(target, 'media', 'argument',
-          'Dot-segments cannot be used in media paths; use subresource paths instead');
+        define(target, {
+          class: 'invalid',
+          ...invalid('media', 'argument',
+            'Dot-segments cannot be used in media paths; use subresource paths instead')
+        });
         return false;
       }
       break;
     default:
-      markInvalid(target, 'media', 'argument', 'Invalid protocol');
+      define(target, { class: 'invalid', ...invalid('media', 'argument', 'Invalid protocol') });
       return false;
   }
   if (alt.includes(Command.Escape)) {
-    define(target, { alt: target.getAttribute('alt')?.replace(CmdRegExp.Escape, '') });
-    markInvalid(target, 'media', 'content',
-      `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`);
+    define(target, {
+      class: 'invalid',
+      alt: target.getAttribute('alt')?.replace(CmdRegExp.Escape, ''),
+      ...invalid('media', 'argument',
+      `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`)
+    });
     return false;
   }
   return true;

package/src/parser/inline/reference.ts

@@ -6,6 +6,7 @@ import { str } from '../source';
 import { blank, trimBlankStart, trimBlankNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { invalid } from '../util';
 
 export const reference: ReferenceParser = lazy(() => constraint(State.reference, false, surround(
   '[[',
@@ -38,12 +39,7 @@ const abbr: ReferenceParser.AbbrParser = surround(
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
   switch (ns[0]) {
     case '':
-      return {
-        class: 'invalid',
-        'data-invalid-syntax': 'reference',
-        'data-invalid-type': 'syntax',
-        'data-invalid-message': 'Invalid abbreviation',
-      };
+      return { class: 'invalid', ...invalid('reference', 'syntax', 'Invalid abbreviation') };
     case '\n':
       const abbr = ns[1] as string;
       ns[0] = ns[1] = '';

package/src/parser/inline/ruby.ts

@@ -5,6 +5,7 @@ import { sequence, surround, dup, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
 import { isTightNodeStart } from '../visibility';
+import { invalid } from '../util';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -104,9 +105,7 @@ function attributes(texts: string[], rubies: string[]): Record<string, string> {
       ss[i] = ss[i].replace(CmdRegExp.Escape, '');
       attrs ??= {
         class: 'invalid',
-        'data-invalid-syntax': 'ruby',
-        'data-invalid-type': ss === texts ? 'content' : 'argument',
-        'data-invalid-message': 'Invalid HTML entity',
+        ...invalid('ruby', ss === texts ? 'content' : 'argument', 'Invalid HTML entity'),
       };
     }
   }

package/src/parser/util.ts

@@ -75,6 +75,18 @@ export function repeat<T extends HTMLElement | string>(symbol: string, parser: P
   };
 }
 
+export function invalid(
+  syntax: string,
+  type: string,
+  message: string,
+): Record<string, string> {
+  return {
+    'data-invalid-syntax': syntax,
+    'data-invalid-type': type,
+    'data-invalid-message': message,
+  };
+}
+
 export function markInvalid<T extends Element>(
   el: T,
   syntax: string,