securemark 0.289.6 → 0.290.0

package/src/parser/inline/media.ts

@@ -50,16 +50,23 @@ export const media: MediaParser = lazy(() => constraint(State.media, false, vali
     const INSECURE_URI = params.shift()!;
     assert(INSECURE_URI === INSECURE_URI.trim());
     assert(!INSECURE_URI.match(/\s/));
-    const url = new ReadonlyURL(
-      resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
-      context.host?.href || location.href);
+    // altが空だとエラーが見えないため埋める。
+    text ||= INSECURE_URI;
+    let uri: ReadonlyURL | undefined;
+    try {
+      uri = new ReadonlyURL(
+        resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
+        context.host?.href || location.href);
+    }
+    catch {
+    }
     let cache: HTMLElement | undefined;
     const el = undefined
-      || (cache = context.caches?.media?.get(url.href)?.cloneNode(true))
-      || html('img', { class: 'media', 'data-src': url.source, alt: text });
+      || uri && (cache = context.caches?.media?.get(uri.href)?.cloneNode(true))
+      || html('img', { class: 'media', 'data-src': uri?.source });
     assert(!el.matches('.invalid'));
-    cache?.hasAttribute('alt') && cache.setAttribute('alt', text);
-    if (!sanitize(el, url, text)) return [[el], rest];
+    el.setAttribute('alt', text);
+    if (!sanitize(el, uri, text)) return [[el], rest];
     assert(!el.matches('.invalid'));
     define(el, attributes('media', push([], el.classList), optspec, params));
     assert(el.matches('img') || !el.matches('.invalid'));
@@ -97,34 +104,36 @@ const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([
   linkoption,
 ]));
 
-function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
+function sanitize(target: HTMLElement, uri: ReadonlyURL | undefined, alt: string): boolean {
   assert(target.tagName === 'IMG');
   assert(!target.matches('.invalid'));
-  switch (uri.protocol) {
+  let type: string;
+  let message: string;
+  if (!alt.includes(Command.Error)) switch (uri?.protocol) {
+    case undefined:
+      type = 'argument';
+      message = 'Invalid URI';
+      break;
     case 'http:':
     case 'https:':
       assert(uri.host);
-      if (/\/\.\.?(?:\/|$)/.test('/' + uri.source.slice(0, uri.source.search(/[?#]|$/)))) {
-        define(target, {
-          class: 'invalid',
-          ...invalid('media', 'argument',
-            'Dot-segments cannot be used in media paths; use subresource paths instead')
-        });
-        return false;
-      }
+      if (!/\/\.\.?(?:\/|$)/.test('/' + uri.source.slice(0, uri.source.search(/[?#]|$/)))) return true;
+      type = 'argument';
+      message = 'Dot-segments cannot be used in media paths; use subresource paths instead';
       break;
     default:
-      define(target, { class: 'invalid', ...invalid('media', 'argument', 'Invalid protocol') });
-      return false;
+      type = 'argument';
+      message = 'Invalid protocol';
   }
-  if (alt.includes(Command.Error)) {
-    define(target, {
-      class: 'invalid',
-      alt: target.getAttribute('alt')?.replace(CmdRegExp.Error, ''),
-      ...invalid('media', 'argument',
-      `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`)
-    });
-    return false;
+  else {
+    target.setAttribute('alt', alt.replace(CmdRegExp.Error, ''));
+    type = 'argument';
+    message = `Invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`;
   }
-  return true;
+  define(target, {
+    'data-src': null,
+    class: 'invalid',
+    ...invalid('link', type, message),
+  });
+  return false;
 }

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

@@ -16,8 +16,8 @@ describe('Unit: parser/inline/shortmedia', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('!http://host')), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt=""></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('!https://host')), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!http://host')), [['<a href="http://host" target="_blank"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!https://host')), [['<a href="https://host" target="_blank"><img class="media" data-src="https://host" alt="https://host"></a>'], '']);
     });
 
   });

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

@@ -12,8 +12,6 @@ describe('Unit: parser/inline/template', () => {
       assert.deepStrictEqual(inspect(parser('{}')), undefined);
       assert.deepStrictEqual(inspect(parser('{{')), undefined);
       assert.deepStrictEqual(inspect(parser('{{\\}}')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{\n}}')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{\\\n}}')), undefined);
       assert.deepStrictEqual(inspect(parser('{{a}b}')), undefined);
       assert.deepStrictEqual(inspect(parser('{{{a}}')), undefined);
       assert.deepStrictEqual(inspect(parser(' {{}}')), undefined);
@@ -24,6 +22,8 @@ describe('Unit: parser/inline/template', () => {
       assert.deepStrictEqual(inspect(parser('{{}}}')), [['<span class="template">{{}}</span>'], '}']);
       assert.deepStrictEqual(inspect(parser('{{ }}')), [['<span class="template">{{ }}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('{{ a }}')), [['<span class="template">{{ a }}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{\n}}')), [['<span class="template">{{<br>}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('{{\\\n}}')), [['<span class="template">{{\\<br>}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('{{a}}')), [['<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('{{a b}}')), [['<span class="template">{{a b}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('{{\\}}}')), [['<span class="template">{{\\}}}</span>'], '']);

package/src/parser/inline/template.ts

@@ -2,18 +2,17 @@ import { TemplateParser } from '../inline';
 import { Recursion, Backtrack } from '../context';
 import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
-import { html } from 'typed-dom/dom';
+import { unshift, push } from 'spica/array';
+import { html, defrag } from 'typed-dom/dom';
 
 export const template: TemplateParser = lazy(() => surround(
-  '{{',
+  str('{{'),
   precedence(1,
   some(union([bracket, escsource]), '}')),
-  '}}',
+  str('}}'),
   true,
-  ([, ns = []], rest, context) =>
-    context.linebreak === undefined
-      ? [[html('span', { class: 'template' }, `{{${ns.join('')}}}`)], rest]
-      : undefined,
+  ([as, bs = [], cs], rest) =>
+    [[html('span', { class: 'template' }, defrag(push(unshift(as, bs), cs)))], rest],
   undefined,
   [3 | Backtrack.doublebracket, 1 | Backtrack.bracket]));
 

package/src/parser/inline.test.ts

@@ -139,6 +139,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('(([[a] ]))')), [['<sup class="annotation"><span>[[a] ]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('(([["*(*"] ]))')), [['<sup class="annotation"><span>[["*(*"] ]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('(([:a\n]')), [['(', '(', '<span class="invalid">a<br></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('(({{\n}}')), [['(', '(', '<span class="template">{{<br>}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '(', '(', '"', '"', ')', ')'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference"><span>a</span></sup>'], '']);

package/src/parser/source/escapable.test.ts

@@ -20,13 +20,13 @@ describe('Unit: parser/source/escsource', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
       assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
       assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
-      //assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
-      //assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
-      //assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '<br>'], '']);
     });
 
     it('linebreak', () => {
-      //assert.deepStrictEqual(inspect(parser('\n\n')), [['\n', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('\n\n')), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
@@ -39,7 +39,7 @@ describe('Unit: parser/source/escsource', () => {
       assert.deepStrictEqual(inspect(parser('\\a')), [['\\a'], '']);
       assert.deepStrictEqual(inspect(parser('\\$')), [['\\$'], '']);
       assert.deepStrictEqual(inspect(parser('\\　')), [['\\　'], '']);
-      //assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '<br>'], '']);
     });
 
   });

package/src/parser/source/escapable.ts

@@ -2,6 +2,7 @@ import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
 import { nonWhitespace } from './text';
+import { html } from 'typed-dom/dom';
 
 const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
@@ -20,7 +21,6 @@ export const escsource: EscapableSourceParser = ({ source, context }) => {
           consume(-1, context);
           return [[], source.slice(1)];
         case Command.Escape:
-          assert(false);
           consume(1, context);
           return [[source.slice(1, 2)], source.slice(2)];
         case '\\':
@@ -35,7 +35,7 @@ export const escsource: EscapableSourceParser = ({ source, context }) => {
           }
         case '\n':
           context.linebreak ??= source.length;
-          return [[source[0]], source.slice(1)];
+          return [[html('br')], source.slice(1)];
         default:
           assert(source[0] !== '\n');
           const b = source[0].trimStart() === '';

package/src/parser/source/unescapable.test.ts

@@ -20,13 +20,13 @@ describe('Unit: parser/source/unescapable', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
       assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
       assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
-      //assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
-      //assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
-      //assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '<br>'], '']);
     });
 
     it('linebreak', () => {
-      //assert.deepStrictEqual(inspect(parser('\n\n')), [['\n', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('\n\n')), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
@@ -39,7 +39,7 @@ describe('Unit: parser/source/unescapable', () => {
       assert.deepStrictEqual(inspect(parser('\\a')), [['\\', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('\\`')), [['\\', '`'], '']);
       assert.deepStrictEqual(inspect(parser('\\　')), [['\\', '　'], '']);
-      //assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '<br>'], '']);
     });
 
   });

package/src/parser/source/unescapable.ts

@@ -2,6 +2,7 @@ import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
 import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
+import { html } from 'typed-dom/dom';
 
 export const unescsource: UnescapableSourceParser = ({ source, context }) => {
   if (source === '') return;
@@ -18,12 +19,11 @@ export const unescsource: UnescapableSourceParser = ({ source, context }) => {
           consume(-1, context);
           return [[], source.slice(1)];
         case Command.Escape:
-          assert(false);
           consume(1, context);
           return [[source.slice(1, 2)], source.slice(2)];
         case '\n':
           context.linebreak ??= source.length;
-          return [[source[0]], source.slice(1)];
+          return [[html('br')], source.slice(1)];
         default:
           assert(source[0] !== '\n');
           const b = source[0].trimStart() === '';

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

@@ -39,9 +39,9 @@ describe('Unit: renderer/render/media', () => {
     });
 
     it('image', () => {
-      assert(media(location.href, parse('!{/ 4x3}').querySelector('img')!, {}, caches.media)!.matches(`[src="/"][alt=""][width="4"][height="3"]:not([aspect-ratio])`));
-      assert(media(location.href, parse('!{/ 4:3}').querySelector('img')!, {}, caches.media)!.matches(`[src="/"][alt=""][aspect-ratio="4/3"]:not([width]):not([height])`));
-      assert(media(location.href, parse('!{/ 4x3}').querySelector('img')!, {}, caches.media)!.matches(`[src="/"][alt=""][width="4"][height="3"]:not([aspect-ratio])`));
+      assert(media(location.href, parse('!{/ 4x3}').querySelector('img')!, {}, caches.media)!.matches(`[src="/"][alt="/"][width="4"][height="3"]:not([aspect-ratio])`));
+      assert(media(location.href, parse('!{/ 4:3}').querySelector('img')!, {}, caches.media)!.matches(`[src="/"][alt="/"][aspect-ratio="4/3"]:not([width]):not([height])`));
+      assert(media(location.href, parse('!{/ 4x3}').querySelector('img')!, {}, caches.media)!.matches(`[src="/"][alt="/"][width="4"][height="3"]:not([aspect-ratio])`));
     });
 
   });