securemark 0.287.1 → 0.288.1

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';
 
@@ -26,14 +27,12 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
                     ...es,
                   ])),
                 ]),
-              ])), false)),
+              ]), false), false)),
           ({ source }) => [[
             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/autolink/account.ts

@@ -21,7 +21,8 @@ export const account: AutolinkParser.AccountParser = lazy(() => rewrite(
           ? `https://${source.slice(1).replace('/', '/@')}`
           : `/${source}`
         } }`,
-      unsafelink),
+      unsafelink,
+      false),
       ([el]) => [define(el, { class: 'account' })]))),
     ({ source }) => [[source], ''],
   ])));

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

@@ -24,7 +24,8 @@ export const anchor: AutolinkParser.AnchorParser = lazy(() => validate('>>',
             ? `/@${source.slice(2).replace('/', '/timeline?at=')}`
             : `?at=${source.slice(2)}`
           } }`,
-        unsafelink),
+        unsafelink,
+        false),
         ([el]) => [define(el, { class: 'anchor' })]))),
       ({ source }) => [[source], ''],
     ]))));

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

@@ -11,7 +11,8 @@ export const hashnum: AutolinkParser.HashnumParser = lazy(() => rewrite(
   union([
     constraint(State.autolink, false, state(State.autolink, fmap(convert(
       source => `[${source}]{ ${source.slice(1)} }`,
-      unsafelink),
+      unsafelink,
+      false),
       ([el]) => [define(el, { class: 'hashnum', href: null })]))),
     ({ source }) => [[source], ''],
   ])));

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

@@ -20,7 +20,8 @@ export const hashtag: AutolinkParser.HashtagParser = lazy(() => rewrite(
   union([
     constraint(State.autolink, false, state(State.autolink, fmap(convert(
       source => `[${source}]{ ${`/hashtags/${source.slice(1)}`} }`,
-      unsafelink),
+      unsafelink,
+      false),
       ([el]) => [define(el, { class: 'hashtag' })]))),
     ({ source }) => [[source], ''],
   ])));

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

@@ -16,7 +16,8 @@ export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'ht
   union([
     constraint(State.autolink, false, state(State.autolink, convert(
       url => `{ ${url} }`,
-      unsafelink))),
+      unsafelink,
+      false))),
     ({ source }) => [[source], ''],
   ]))));
 
@@ -29,7 +30,8 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => open(
       union([
         constraint(State.autolink, false, state(State.autolink, convert(
           url => `{ ${url} }`,
-          unsafelink))),
+          unsafelink,
+          false))),
         ({ source }) => [[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/inline/shortmedia.ts

@@ -9,7 +9,8 @@ export const shortmedia: ShortMediaParser = constraint(State.media, false, rewri
   open('!', url),
   convert(
     source => `!{ ${source.slice(1)} }`,
-    union([media]))));
+    union([media]),
+    false)));
 
 export const lineshortmedia: ShortMediaParser.LineShortMediaParser = open(
   linebreak,
@@ -17,4 +18,5 @@ export const lineshortmedia: ShortMediaParser.LineShortMediaParser = open(
     /^!https?:\/\/\S+(?=[^\S\n]*(?:$|\n))/,
     convert(
       source => `!{ ${source.slice(1)} }`,
-      union([media]))));
+      union([media]),
+      false)));

package/src/parser/inline/template.ts

@@ -11,7 +11,7 @@ export const template: TemplateParser = lazy(() => surround(
   '}}',
   true,
   ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('')}}}`)], rest],
-  undefined, [3 | Backtrack.linedoublebracket, 1 | Backtrack.lineescbracket], Backtrack.bracket));
+  undefined, [3 | Backtrack.linedoublebracket, 1 | Backtrack.lineescbracket]));
 
 const bracket: TemplateParser.BracketParser = lazy(() => union([
   surround(str('('), recursion(Recursion.terminal, some(union([bracket, escsource]), ')')), str(')'), true,

package/src/parser/inline.test.ts

@@ -169,6 +169,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('_http://host_')), [['_', '<a class="url" href="http://host" target="_blank">http://host</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('*http://host*')), [['<em><a class="url" href="http://host" target="_blank">http://host</a></em>'], '']);
       assert.deepStrictEqual(inspect(parser('(http://host)')), [['<span class="paren">(<a class="url" href="http://host" target="_blank">http://host</a>)</span>'], '']);
+      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(' 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>', 'い'], '']);
     });

package/src/parser/source/str.ts

@@ -21,7 +21,8 @@ export function str(pattern: string | RegExp, not?: string): Parser<string, Cont
         const m = source.match(pattern);
         count && m && consume(m[0].length, context);
         if (m && not && source.slice(m[0].length, m[0].length + not.length) === not) return;
-        return m && m[0].length > 0
+        //assert(!m || m[0]);
+        return m
           ? [[m[0]], source.slice(m[0].length)]
           : undefined;
       };

package/src/parser/util.ts

@@ -4,9 +4,12 @@ import { Parser, Result, Ctx, Tree, Context, eval, exec } from '../combinator/da
 import { convert } from '../combinator';
 import { define } from 'typed-dom/dom';
 
-export function lineable<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function lineable<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  return convert(source => `\r${source}`, parser);
+export function lineable<P extends Parser<HTMLElement | string>>(parser: P, fillTrailingLinebreak?: boolean): P;
+export function lineable<T extends HTMLElement | string>(parser: Parser<T>, fillTrailingLinebreak = false): Parser<T> {
+  return convert(
+    source => `\r${source}${fillTrailingLinebreak && source.at(-1) !== '\n' ? '\n' : ''}`,
+    parser,
+    !fillTrailingLinebreak);
 }
 
 export function repeat<P extends Parser<HTMLElement | string>>(symbol: string, parser: P, cons: (nodes: Tree<P>[], context: Context<P>) => Tree<P>[], termination?: (acc: Tree<P>[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | Tree<P>>): P;
@@ -72,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,

package/src/parser/visibility.ts

@@ -23,7 +23,8 @@ export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Pa
   return union([
     convert(
       source => source.replace(blank.line, line => line.replace(/[\\&<]/g, `${Command.Escape}$&`)),
-      verify(parser, (ns, rest) => !rest && hasVisible(ns))),
+      verify(parser, (ns, rest) => !rest && hasVisible(ns)),
+      false),
     some(union([linebreak, unescsource])),
   ]);
 }
@@ -162,7 +163,8 @@ export function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
 export function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
   return convert(
     source => source.replace(blank.start, ''),
-    parser);
+    parser,
+    true);
 }
 export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {

package/src/util/quote.test.ts

@@ -5,10 +5,10 @@ describe('Unit: util/quote', () => {
   describe('quote', () => {
     it('basic', () => {
       const range = document.createRange();
-      const el = parse('>>1\n>2\n> a\n>>4 `b` ${c}$\n [e](f) ').firstElementChild!;
+      const el = parse('>>1\n> a\n>>?\n> 2\n>>4 `b` ${c}$\n [e](f) ').firstElementChild!;
       range.setStart(el.firstChild!.firstChild!, 0);
       range.setEnd(el.lastChild!.lastChild!.lastChild!, 1);
-      assert(quote('3', range) === `>>>1\n> >2\n>> a\n>>3\n> >>4 \`b\` \${c}$\n>  e`);
+      assert.deepStrictEqual(quote('3', range), `>>>1\n>> a\n>>>?\n>> 2\n>>3\n> >>4 \`b\` \${c}$\n>  e`);
     });
 
     it('adjustment', () => {