securemark 0.243.0 → 0.244.0

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

@@ -26,14 +26,17 @@ export const segment_: TableParser.SegmentParser = block(validate('~~~',
 export const table: TableParser = block(validate('~~~', recover(fmap(
   fence(opener, 10000),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, param]: string[], _, context) => {
-    if (!closer || param.trimStart()) return [html('pre', {
+  ([body, overflow, closer, opener, delim, param]: string[], _, context) => {
+    if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
       'data-invalid-syntax': 'table',
-      'data-invalid-type': !closer ? 'fence' : 'argument',
-      'data-invalid-message': !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid argument',
-    }, `${opener}${body}${closer}`)];
+      '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}"` :
+        'Invalid argument',
+    }, `${opener}${body}${overflow || closer}`)];
     return eval(parser(body, context)) ?? [html('table')];
   }),
   (source, _, reason) =>

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

@@ -19,10 +19,12 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser('$$ $$\n$$')), undefined);
       assert.deepStrictEqual(inspect(parser('$$lang\n$$')), [['<pre class="invalid" translate="no">$$lang\n$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('$$ param\n$$')), [['<pre class="invalid" translate="no">$$ param\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('$$\n$$\n$$')), [['<pre class="invalid" translate="no">$$\n$$\n$$</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('$$\n$$$')), [['<pre class="invalid" translate="no">$$\n$$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('$$$\n$$')), [['<pre class="invalid" translate="no">$$$\n$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser('$$$\n$$$')), [['<pre class="invalid" translate="no">$$$\n$$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser(' $$\n$$')), undefined);
-      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(101)}$$`), '>'), [['<pre class="invalid" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(301)}$$`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('basic', () => {
@@ -34,12 +36,10 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser('$$\n\\\n$$')), [['<div class="math" translate="no">$$\n\\\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$\n$$')), [['<div class="math" translate="no">$$\n$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$\n\n$$')), [['<div class="math" translate="no">$$\n$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser('$$\n$$\n$$')), [['<div class="math" translate="no">$$\n$$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$$\n\n$$')), [['<div class="math" translate="no">$$\n$$</div>'], '\n$$']);
       assert.deepStrictEqual(inspect(parser('$$\n$$$\n$$')), [['<div class="math" translate="no">$$\n$$$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser('$$\n$$$\n\n$$')), [['<div class="math" translate="no">$$\n$$$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser('$$\n$$\n$$')), [['<div class="math" translate="no">$$\n$$\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(100)}$$`), '>'), [['<div class="math" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser(`$$\n0${'\n'.repeat(300)}$$`), '>'), [['<div class="math" translate="no">'], '']);
     });
 
   });

package/src/parser/block/mathblock.ts

@@ -6,23 +6,26 @@ import { html } from 'typed-dom/dom';
 const opener = /^(\${2,})(?!\$)([^\n]*)(?:$|\n)/;
 
 export const segment: MathBlockParser.SegmentParser = block(validate('$$',
-  clear(fence(opener, 100))));
+  clear(fence(opener, 300))));
 
 export const segment_: MathBlockParser.SegmentParser = block(validate('$$',
-  clear(fence(opener, 100, false))), false);
+  clear(fence(opener, 300, false))), false);
 
 export const mathblock: MathBlockParser = block(validate('$$', fmap(
-  fence(opener, 100),
+  fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, closer, opener, delim, param]: string[], _, { caches: { math: cache = undefined } = {} }) => [
-    delim.length === 2 && closer && param.trimStart() === ''
+  ([body, overflow, closer, opener, delim, param]: string[], _, { caches: { math: cache = undefined } = {} }) => [
+    delim.length === 2 && closer && !overflow && param.trimStart() === ''
       ? cache?.get(`${delim}\n${body}${delim}`)?.cloneNode(true) as HTMLDivElement ||
         html('div', { class: 'math', translate: 'no' }, `${delim}\n${body}${delim}`)
       : html('pre', {
           class: 'invalid',
           translate: 'no',
           'data-invalid-syntax': 'mathblock',
-          'data-invalid-type': delim.length > 2 ? 'syntax' : !closer ? 'fence' : 'argument',
-          'data-invalid-message': delim.length > 2 ? 'Invalid syntax' : !closer ? `Missing the closing delimiter "${delim}"` : 'Invalid argument',
-        }, `${opener}${body}${closer}`),
+          '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',
+        }, `${opener}${body}${overflow || closer}`),
   ])));

package/src/parser/block/table.ts

@@ -29,9 +29,9 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
   rewrite(contentline, source => [[
     html('tr', {
       class: 'invalid',
-      'data-invalid-syntax': 'tablerow',
+      'data-invalid-syntax': 'table-row',
       'data-invalid-type': 'syntax',
-      'data-invalid-message': 'Invalid table row',
+      'data-invalid-message': 'Missing the start symbol of the table row',
     }, [html('td', source.replace('\n', ''))])
   ], ''])));
 

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

@@ -93,22 +93,29 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<small __proto__>a</small>')), undefined);
       assert.deepStrictEqual(inspect(parser('<small constructor>a</small>')), [['<span class="invalid">&lt;small constructor&gt;a&lt;/small&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<small toString>a</small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small X>a</small>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<small x>a</small>')), [['<span class="invalid">&lt;small x&gt;a&lt;/small&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo>a</bdo>')), [['<span class="invalid">&lt;bdo&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo >a</bdo>')), [['<span class="invalid">&lt;bdo &gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo __proto__>a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo constructor>a</bdo>')), [['<span class="invalid">&lt;bdo constructor&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo toString>a</bdo>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdo X>a</bdo>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<bdo x>a</bdo>')), [['<span class="invalid">&lt;bdo x&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir>a</bdo>')), [['<span class="invalid">&lt;bdo dir&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir=>a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir=rtl>a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir=">a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir="">a</bdo>')), [['<span class="invalid">&lt;bdo dir=""&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" dir="rtl">a</bdo>')), [['<span class="invalid">&lt;bdo dir="rtl" dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdo diR="rtl">a</bdo>')), undefined);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" >a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl"  >a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo  dir="rtl">a</bdo>')), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr constructor>')), [['<wbr class="invalid">'], '']);
+      assert.deepStrictEqual(inspect(parser('<wbr X>')), undefined);
+      assert.deepStrictEqual(inspect(parser('<wbr x>')), [['<wbr class="invalid">'], '']);
     });
 
   });

package/src/parser/inline/html.ts

@@ -1,5 +1,5 @@
 import { undefined } from 'spica/global';
-import { isFrozen, ObjectEntries, ObjectFreeze, ObjectSetPrototypeOf, ObjectValues } from 'spica/alias';
+import { isFrozen, ObjectEntries } from 'spica/alias';
 import { MarkdownParser } from '../../../markdown';
 import { HTMLParser } from '../inline';
 import { union, some, validate, context, creator, surround, open, match, lazy } from '../../combinator';
@@ -11,14 +11,14 @@ import { memoize } from 'spica/memoize';
 import { Cache } from 'spica/cache';
 import { unshift, push, splice, join } from 'spica/array';
 
-const tags = ObjectFreeze(['sup', 'sub', 'small', 'bdo', 'bdi']);
+const tags = Object.freeze(['wbr', 'sup', 'sub', 'small', 'bdo', 'bdi']);
 const attrspec = {
   bdo: {
-    dir: ObjectFreeze(['ltr', 'rtl'] as const),
+    dir: Object.freeze(['ltr', 'rtl'] as const),
   },
 } as const;
-ObjectSetPrototypeOf(attrspec, null);
-ObjectValues(attrspec).forEach(o => ObjectSetPrototypeOf(o, null));
+Object.setPrototypeOf(attrspec, null);
+Object.values(attrspec).forEach(o => Object.setPrototypeOf(o, null));
 
 export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, union([
   match(
@@ -29,7 +29,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
         `<${tag}`, some(union([attribute])), /^\s*>/, true,
         ([, bs = []], rest) =>
           [[h(tag as 'span', attributes('html', [], attrspec[tag], bs))], rest]),
-    ([, tag]) => tag)),
+    ([, tag]) => tags.indexOf(tag), [])),
   match(
     /^(?=<(sup|sub|small)(?=[^\S\n]|>))/,
     memoize(
@@ -69,7 +69,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
         str(`</${tag}>`), false,
         ([as, bs, cs], rest, context) =>
           [[elem(tag, as, defrag(bs), cs, context)], rest])),
-      ([, tag]) => tag)),
+    ([, tag]) => tags.indexOf(tag), [])),
   match(
     /^(?=<(bdo|bdi)(?=[^\S\n]|>))/,
     memoize(
@@ -82,11 +82,11 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
           open(/^\n?/, some(inline, '</'), true),
         ]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
-        ([as, bs, cs], rest) =>
-          [[elem(tag, as, defrag(bs), cs, {})], rest],
+        ([as, bs, cs], rest, context) =>
+          [[elem(tag, as, defrag(bs), cs, context)], rest],
         ([as, bs], rest) =>
           as.length === 1 ? [unshift(as, bs), rest] : undefined)),
-    ([, tag]) => tag)),
+    ([, tag]) => tags.indexOf(tag), [])),
   match(
     /^(?=<([a-z]+)(?=[^\S\n]|>))/,
     memoize(
@@ -99,12 +99,12 @@ export const html: HTMLParser = lazy(() => creator(validate('<', validate(/^<[a-
           open(/^\n?/, some(inline, '</'), true),
         ]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
-        ([as, bs, cs], rest) =>
-          [[elem(tag, as, defrag(bs), cs, {})], rest],
+        ([as, bs, cs], rest, context) =>
+          [[elem(tag, as, defrag(bs), cs, context)], rest],
         ([as, bs], rest) =>
           as.length === 1 ? [unshift(as, bs), rest] : undefined)),
     ([, tag]) => tag,
-    new Cache(1000))),
+    new Cache(10000))),
 ])))));
 
 export const attribute: HTMLParser.TagParser.AttributeParser = union([
@@ -133,12 +133,11 @@ function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: strin
       }
       break;
   }
-  let attrs: Record<string, string | undefined> | undefined;
+  const attrs = attributes('html', [], attrspec[tag], as.slice(1, -1));
   switch (true) {
-    case 'data-invalid-syntax' in (attrs = attributes('html', [], attrspec[tag], as.slice(1, -1) as string[])):
+    case 'data-invalid-syntax' in attrs:
       return invalid('attribute', 'Invalid HTML attribute', as, bs, cs);
     default:
-      assert(attrs);
       return h(tag as 'span', attrs, bs);
   }
 }
@@ -158,7 +157,7 @@ const requiredAttributes = memoize(
 
 export function attributes(
   syntax: string,
-  classes: string[],
+  classes: readonly string[],
   spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>> | undefined,
   params: string[],
 ): Record<string, string | undefined> {
@@ -183,8 +182,7 @@ export function attributes(
   }
   invalid ||= !!spec && !requiredAttributes(spec).every(name => name in attrs);
   if (invalid) {
-    !classes.includes('invalid') && classes.push('invalid');
-    attrs['class'] = join(classes, ' ');
+    attrs['class'] = join(classes.includes('invalid') ? classes : unshift(classes, ['invalid']), ' ');
     attrs['data-invalid-syntax'] = syntax;
     attrs['data-invalid-type'] = 'argument';
     attrs['data-invalid-message'] = 'Invalid argument';

package/src/parser/inline/link.ts

@@ -1,5 +1,4 @@
-import { location, encodeURI, decodeURI, Location } from 'spica/global';
-import { ObjectSetPrototypeOf } from 'spica/alias';
+import { undefined, location, encodeURI, decodeURI, Location } from 'spica/global';
 import { LinkParser } from '../inline';
 import { eval } from '../../combinator/data/parser';
 import { union, inits, tails, some, validate, guard, context, creator, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
@@ -14,7 +13,7 @@ import { ReadonlyURL } from 'spica/url';
 const optspec = {
   rel: ['nofollow'],
 } as const;
-ObjectSetPrototypeOf(optspec, null);
+Object.setPrototypeOf(optspec, null);
 
 export const link: LinkParser = lazy(() => creator(10, validate(['[', '{'], '}', '\n', bind(
   guard(context => context.syntax?.inline?.link ?? true,

package/src/parser/inline/media.ts

@@ -1,5 +1,4 @@
 import { undefined, location } from 'spica/global';
-import { ObjectSetPrototypeOf } from 'spica/alias';
 import { MediaParser } from '../inline';
 import { union, inits, tails, some, validate, verify, guard, creator, surround, open, dup, lazy, fmap, bind } from '../../combinator';
 import { link, uri, option as linkoption, resolve } from './link';
@@ -16,7 +15,7 @@ const optspec = {
   'aspect-ratio': [],
   rel: undefined,
 } as const;
-ObjectSetPrototypeOf(optspec, null);
+Object.setPrototypeOf(optspec, null);
 
 export const media: MediaParser = lazy(() => creator(10, validate(['![', '!{'], '}', '\n', bind(verify(fmap(open(
   '!',

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

@@ -1,6 +1,6 @@
-import { define } from 'typed-dom/dom';
-import { Collection } from 'spica/collection';
 import { ObjectFromEntries } from 'spica/alias';
+import { Collection } from 'spica/collection';
+import { define } from 'typed-dom/dom';
 
 export function image(source: HTMLImageElement, url: URL, cache?: Collection<string, HTMLElement>): HTMLImageElement {
   if (cache?.has(url.href)) return define(

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

@@ -1,5 +1,5 @@
-import { html } from 'typed-dom/dom';
 import { ObjectFromEntries } from 'spica/alias';
+import { html } from 'typed-dom/dom';
 
 const extensions = [
   '.webm',

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

@@ -1,3 +1,4 @@
+import { undefined } from 'spica/global';
 import { html } from 'typed-dom/dom';
 
 export function youtube(source: HTMLImageElement, url: URL): HTMLElement | undefined {