securemark 0.221.0 → 0.224.1

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

@@ -29,26 +29,34 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]{   }')), undefined);
       assert.deepStrictEqual(inspect(parser('![]]{/}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{{a}}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{a\nb}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{a\\\nb}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{ a}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{ a\n}')), 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);
+      assert.deepStrictEqual(inspect(parser('![]{ b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![]{ b\n}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![ ]{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![ ]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![  ]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![\n]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![\\ ]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![\\\n]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![	]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![[]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![]]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a]{}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![ a]{#}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![ a ]{#}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![\\ a ]{#}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![a\nb]{#}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![a\\\nb]{#}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![\\ a ]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![ \\ a ]{b}')), 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(' ![]{a}')), undefined);
+      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(' ![]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{/}')), undefined);
     });
 
@@ -61,8 +69,11 @@ describe('Unit: parser/inline/media', () => {
       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>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{./b}')), [['<a href="./b" target="_blank"><img class="media" data-src="./b" 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>`], '']);
+      assert.deepStrictEqual(inspect(parser('![ a]{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![ a ]{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![a ]{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![a  ]{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![a b]{c}')), [['<a href="c" target="_blank"><img class="media" data-src="c" alt="a b"></a>'], '']);

package/src/parser/inline/media.ts

@@ -6,7 +6,6 @@ import { link, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { htmlentity } from './htmlentity';
 import { txt, str } from '../source';
-import { verifyStartTight } from '../util';
 import { html, define } from 'typed-dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push, join } from 'spica/array';
@@ -24,28 +23,29 @@ export const media: MediaParser = lazy(() => creator(10, bind(verify(fmap(open(
   validate(['[', '{'], '}', '\n',
   guard(context => context.syntax?.inline?.media ?? true,
   tails([
-    dup(surround(/^\[(?!\\?\s)/, some(union([htmlentity, bracket, txt]), ']', /^\\?\n/), ']', true)),
+    dup(surround(/^\[(?!\s*\\\s)/, some(union([htmlentity, bracket, txt]), ']', /^\\?\n/), ']', true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]?}/)),
   ])))),
-  ([as, bs]) => bs ? [[join(as)], bs] : [[''], as]),
-  ([[text]]) => verifyStartTight([text || '-'])),
+  ([as, bs]) => bs ? [[join(as).trim() || join(as)], bs] : [[''], as]),
+  ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
     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 || location),
+      resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
       context.host?.href || location.href);
-    const cache = context.caches?.media;
-    const cached = cache?.has(url.href);
-    const el = cache && cached
-      ? cache.get(url.href)!.cloneNode(true)
-      : html('img', { class: 'media', 'data-src': url.source, alt: text.trimEnd() });
-    if (!cached && !sanitize(url, el)) return [[el], rest];
-    cached && el.hasAttribute('alt') && el.setAttribute('alt', text.trimEnd());
+    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 });
+    assert(!el.matches('.invalid'));
+    if (!cache && !sanitize(url, el)) return [[el], rest];
+    assert(!el.matches('.invalid'));
+    cache?.hasAttribute('alt') && cache?.setAttribute('alt', text);
     define(el, attributes('media', push([], el.classList), optspec, params));
     assert(el.matches('img') || !el.matches('.invalid'));
-    if (context.syntax?.inline?.link === false || cached && el.tagName !== 'IMG') return [[el], rest];
+    if (context.syntax?.inline?.link === false || cache && cache.tagName !== 'IMG') return [[el], rest];
     return fmap(
       link as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
@@ -67,18 +67,29 @@ const option: MediaParser.ParameterParser.OptionParser = union([
 
 function sanitize(uri: ReadonlyURL, target: HTMLElement): boolean {
   assert(target.tagName === 'IMG');
+  assert(!target.matches('.invalid'));
+  if (/\/\.\.?(?:\/|$)/.test('/' + uri.source.slice(0, uri.source.search(/[?#]|$/)))) {
+    define(target, {
+      class: void target.classList.add('invalid'),
+      'data-invalid-syntax': 'media',
+      'data-invalid-type': 'argument',
+      'data-invalid-description': 'Dot-segments cannot be used in media paths; use subresource paths instead.',
+    });
+    return false;
+  }
   switch (uri.protocol) {
     case 'http:':
     case 'https:':
       assert(uri.host);
-      return true;
+      break;
+    default:
+      define(target, {
+        class: void target.classList.add('invalid'),
+        'data-invalid-syntax': 'media',
+        'data-invalid-type': 'argument',
+        'data-invalid-description': 'Invalid protocol.',
+      });
+      return false;
   }
-  assert(!target.classList.contains('invalid'));
-  define(target, {
-    class: void target.classList.add('invalid'),
-    'data-invalid-syntax': 'media',
-    'data-invalid-type': 'argument',
-    'data-invalid-description': 'Invalid protocol.',
-  });
-  return false;
+  return true;
 }

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

@@ -14,8 +14,6 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[]]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[ ]]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[ a]]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[ a ]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\na]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\\ a]]')), undefined);
@@ -34,6 +32,8 @@ describe('Unit: parser/inline/reference', () => {
     });
 
     it('basic', () => {
+      assert.deepStrictEqual(inspect(parser('[[ a]]')), [['<sup class="reference">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[ a ]]')), [['<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a]]')), [['<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a ]]')), [['<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a  ]]')), [['<sup class="reference">a</sup>'], '']);

package/src/parser/inline/reference.ts

@@ -3,13 +3,13 @@ import { ReferenceParser } from '../inline';
 import { union, subsequence, some, validate, verify, focus, guard, context, creator, surround, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isStartTight, trimEnd, stringify } from '../util';
+import { startLoose, isStartLoose, trimNode, stringify } from '../util';
 import { html, defrag } from 'typed-dom';
 
 export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]', '\n', fmap(surround(
   '[[',
   guard(context => context.syntax?.inline?.reference ?? true,
-  startTight(
+  startLoose(
   context({ syntax: { inline: {
     annotation: false,
     reference: false,
@@ -24,15 +24,15 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
     abbr,
     focus('^', c => [['', c], '']),
     some(inline, ']', /^\\?\n/),
-  ])))),
+  ])), ']]')),
   ']]'),
-  ns => [html('sup', attributes(ns), trimEnd(defrag(ns)))]))));
+  ns => [html('sup', attributes(ns), trimNode(defrag(ns)))]))));
 
 const abbr: ReferenceParser.AbbrParser = creator(fmap(verify(surround(
   '^',
   union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
-  /^\|?(?=]])|^\|[^\S\n]+/),
-  (_, rest, context) => isStartTight(rest, context)),
+  /^\|?(?=]])|^\|[^\S\n]/),
+  (_, rest, context) => isStartLoose(rest, context)),
   ([source]) => [html('abbr', source)]));
 
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {

package/src/parser/inline/ruby.ts

@@ -4,7 +4,7 @@ import { eval, exec } from '../../combinator/data/parser';
 import { sequence, validate, verify, focus, creator, surround, lazy, bind } from '../../combinator';
 import { htmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { verifyStartTight } from '../util';
+import { isStartTightNodes } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift, push, join } from 'spica/array';
 
@@ -14,7 +14,7 @@ export const ruby: RubyParser = lazy(() => creator(bind(verify(
     surround('[', focus(/^(?:\\[^\n]|[^\[\]\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\(\)\n])+(?=\))/, text), ')'),
   ])),
-  ([texts]) => verifyStartTight(texts)),
+  ([texts]) => isStartTightNodes(texts)),
   ([texts, rubies], rest) => {
     const tail = typeof texts[texts.length - 1] === 'object'
       ? [texts.pop()!]

package/src/parser/inline/strong.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, close, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { startTight, verifyEndTight, trimEndBR } from '../util';
+import { startTight, isEndTightNodes, trimEndBR } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -12,7 +12,7 @@ export const strong: StrongParser = lazy(() => creator(surround(close(
   startTight(some(union([emphasis, some(inline, '*'), str('*')]), '**')),
   str('**'), false,
   ([as, bs, cs], rest) =>
-    verifyEndTight(bs)
+    isEndTightNodes(bs)
       ? [[html('strong', defrag(trimEndBR(bs)))], rest]
       : [unshift(as, bs), cs[0] + rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/util.ts

@@ -70,6 +70,19 @@ function hasVisible(
   return false;
 }
 
+export function startLoose<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
+export function startLoose<T extends HTMLElement | string>(parser: Parser<T>, except?: string): Parser<T> {
+  return (source, context) =>
+    isStartLoose(source, context, except)
+      ? parser(source, context)
+      : undefined;
+}
+export function isStartLoose(source: string, context: MarkdownParser.Context, except?: string): boolean {
+  source &&= source.replace(/^[^\S\n]+/, '');
+  if (source === '') return true;
+  return source.slice(0, except?.length ?? 0) !== except
+      && isStartTight(source, context);
+}
 export function startTight<P extends Parser<unknown>>(parser: P): P;
 export function startTight<T>(parser: Parser<T>): Parser<T> {
   return (source, context) =>
@@ -77,8 +90,7 @@ export function startTight<T>(parser: Parser<T>): Parser<T> {
       ? parser(source, context)
       : undefined;
 }
-
-export function isStartTight(source: string, context: MarkdownParser.Context): boolean {
+function isStartTight(source: string, context: MarkdownParser.Context): boolean {
   if (source === '') return true;
   switch (source[0]) {
     case ' ':
@@ -117,11 +129,11 @@ export function isStartTight(source: string, context: MarkdownParser.Context): b
       return source[0].trimStart() !== '';
   }
 }
-export function verifyStartTight(nodes: readonly (HTMLElement | string)[]): boolean {
+export function isStartTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;
-  return isVisible(nodes[0]);
+  return isVisible(nodes[0], 0);
 }
-export function verifyEndTight(nodes: readonly (HTMLElement | string)[]): boolean {
+export function isEndTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;
   const last = nodes.length - 1;
   return typeof nodes[last] === 'string' && (nodes[last] as string).length > 1
@@ -130,12 +142,13 @@ export function verifyEndTight(nodes: readonly (HTMLElement | string)[]): boolea
     : isVisible(nodes[last], -1) || last === 0 ||
       isVisible(nodes[last - 1], -1);
 }
-function isVisible(node: HTMLElement | string, position = 0): boolean {
+function isVisible(node: HTMLElement | string, position?: number): boolean {
   if (!node) return false;
   switch (typeof node) {
     case 'string':
-      assert(node.length + position >= 0);
-      const char = node[position >= 0 ? position : node.length + position];
+      const char = position === undefined
+        ? node
+        : node[position >= 0 ? position : node.length + position];
       assert(char);
       switch (char) {
         case ' ':
@@ -160,8 +173,34 @@ function isVisible(node: HTMLElement | string, position = 0): boolean {
   }
 }
 
-export function trimEnd(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
-  assert(verifyStartTight(nodes));
+export function trimNode(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
+  return trimNodeStart(trimNodeEnd(nodes));
+}
+function trimNodeStart(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
+  const skip = nodes.length > 0 &&
+    typeof nodes[nodes.length - 1] === 'object' &&
+    nodes[nodes.length - 1]['className'] === 'indexer'
+    ? [nodes.pop()!]
+    : [];
+  for (
+    let first = nodes[0];
+    nodes.length > 0 &&
+    !isVisible(first, 0) &&
+    !(typeof first === 'object' && first.className === 'comment');
+  ) {
+    assert(nodes.length > 0);
+    if (typeof first === 'string') {
+      const pos = first.length - first.trimStart().length;
+      if (pos > 0) {
+        nodes[0] = first.slice(pos);
+        break;
+      }
+    }
+    nodes.pop();
+  }
+  return push(nodes, skip);
+}
+export function trimNodeEnd(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
   const skip = nodes.length > 0 &&
     typeof nodes[nodes.length - 1] === 'object' &&
     nodes[nodes.length - 1]['className'] === 'indexer'

package/src/renderer/render/math.ts

@@ -13,7 +13,7 @@ export function math(target: HTMLElement, cache?: Collection<string, HTMLElement
 
 async function queue(target: HTMLElement, callback = () => undefined): Promise<void> {
   // @ts-ignore
-  MathJax.typesetPromise || await MathJax.startup.promise;
+  !MathJax.typesetPromise && await MathJax.startup.promise;
   // @ts-ignore
   MathJax.typesetPromise([target]).then(callback);
 }

package/src/renderer/render.ts

@@ -12,7 +12,6 @@ const extend = reduce((opts: RenderingOptions): RenderingOptions =>
 
 export function render(source: HTMLElement, opts: RenderingOptions = {}): void {
   opts = extend(opts);
-  if (source.classList.contains('invalid')) return;
   const base = location.href;
   if (source.matches(selector)) return void render_(base, source, opts);
   for (
@@ -23,7 +22,7 @@ export function render(source: HTMLElement, opts: RenderingOptions = {}): void {
 }
 
 function render_(base: string, source: HTMLElement, opts: RenderingOptions): void {
-  assert(!source.matches('.invalid'));
+  if (source.classList.contains('invalid')) return;
   try {
     switch (true) {
       case !!opts.code

package/tsconfig.json

@@ -1,6 +1,12 @@
 {
   "compilerOptions": {
     "target": "ES2019",
+    "lib": [
+      "ES2019",
+      "ES2021.Promise",
+      "DOM",
+      "DOM.Iterable"
+    ],
     "module": "commonjs",
     "moduleResolution": "node",
     "esModuleInterop": true,