securemark 0.257.0 → 0.257.3

package/src/parser/inline/math.ts

@@ -1,20 +1,19 @@
 import { MathParser } from '../inline';
-import { union, some, validate, rewrite, precedence, creator, surround, lazy } from '../../combinator';
-import { escsource, str } from '../source';
+import { union, some, validate, focus, rewrite, precedence, creator, surround, lazy } from '../../combinator';
+import { escsource, unescsource } from '../source';
 import { html } from 'typed-dom/dom';
 
-const syntax = /^(?:[ ([](?!\$)|\\[\\{}$]?|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/;
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
-export const math: MathParser = lazy(() => validate('$', creator(precedence(7, rewrite(
+export const math: MathParser = lazy(() => validate('$', creator(rewrite(
   union([
-    surround('$', bracket, '$'),
+    surround('$', precedence(6, bracket), '$'),
     surround(
       /^\$(?![\s{}])/,
-      some(union([
+      precedence(3, some(union([
         bracket,
-        str(syntax),
-      ])),
+        focus(/^(?:[ ([](?!\$)|\\[\\{}$]?|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/, some(unescsource)),
+      ]))),
       /^\$(?![0-9A-Za-z])/),
   ]),
   (source, { caches: { math: cache } = {} }) => [[
@@ -30,7 +29,7 @@ export const math: MathParser = lazy(() => validate('$', creator(precedence(7, r
             'data-invalid-message': `"${source.match(forbiddenCommand)![0]}" command is forbidden`,
           },
       source)
-  ], ''])))));
+  ], '']))));
 
 const bracket: MathParser.BracketParser = lazy(() => creator(surround(
   '{',

package/src/parser/inline/media.ts

@@ -1,13 +1,13 @@
 import { undefined, location } from 'spica/global';
 import { MediaParser } from '../inline';
 import { union, inits, tails, some, validate, verify, guard, precedence, creator, surround, open, dup, lazy, fmap, bind } from '../../combinator';
-import { link, uri, option as linkoption, resolve } from './link';
+import { textlink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, push } from 'spica/array';
+import { unshift, shift, push } from 'spica/array';
 
 const optspec = {
   'width': [],
@@ -17,7 +17,7 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10, precedence(3, bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10, precedence(2, bind(verify(fmap(open(
   '!',
   guard(context => context.syntax?.inline?.media ?? true,
   tails([
@@ -28,7 +28,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10,
       true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ]))),
-  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], bs] : [[''], as]),
+  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], shift(bs)[1]] : [[''], shift(as)[1]]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
     assert(text === text.trim());
@@ -54,7 +54,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], creator(10,
     }
     if (context.syntax?.inline?.link === false || cache && cache.tagName !== 'IMG') return [[el], rest];
     return fmap(
-      link as MediaParser,
+      textlink as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
   })))));

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

@@ -14,14 +14,15 @@ 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')), [['', '[['], ' [a']);
       assert.deepStrictEqual(inspect(parser('[[\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\na]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\\\na]]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a\n]]')), [['[['], 'a\n]]']);
-      assert.deepStrictEqual(inspect(parser('[[a\\\n]]')), [['[['], 'a\\\n]]']);
-      assert.deepStrictEqual(inspect(parser('[[a\nb]]')), [['[['], 'a\nb]]']);
-      assert.deepStrictEqual(inspect(parser('[[a\\\nb]]')), [['[['], 'a\\\nb]]']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[['], '*a\nb*]]']);
+      assert.deepStrictEqual(inspect(parser('[[a\n]]')), [['', '[['], 'a\n]]']);
+      assert.deepStrictEqual(inspect(parser('[[a\\\n]]')), [['', '[['], 'a\\\n]]']);
+      assert.deepStrictEqual(inspect(parser('[[a\nb]]')), [['', '[['], 'a\nb]]']);
+      assert.deepStrictEqual(inspect(parser('[[a\\\nb]]')), [['', '[['], 'a\\\nb]]']);
+      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['', '[['], '*a\nb*]]']);
       assert.deepStrictEqual(inspect(parser('[[\\]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[a]b]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), undefined);

package/src/parser/inline/reference.ts

@@ -1,15 +1,16 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { Result } from '../../combinator/data/parser';
 import { union, subsequence, some, validate, guard, context, precedence, creator, recursion, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
+import { optimize } from './link';
 import { str, stropt } from '../source';
-import { regBlankStart, trimBlankStart, trimNodeEnd, stringify } from '../util';
+import { regBlankStart, startLoose, trimNode, stringify } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const reference: ReferenceParser = lazy(() => validate('[[', creator(recursion(precedence(6, surround(
   '[[',
   guard(context => context.syntax?.inline?.reference ?? true,
+  startLoose(
   context({ syntax: { inline: {
     annotation: false,
     reference: false,
@@ -22,12 +23,12 @@ export const reference: ReferenceParser = lazy(() => validate('[[', creator(recu
   }}, delimiters: undefined },
   subsequence([
     abbr,
-    open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 3], [']]', 6]])),
-    trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 3], [']]', 6]])),
-  ]))),
+    open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
+    some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]]),
+  ])), ']')),
   ']]',
   false,
-  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNode(defrag(ns)))])], rest],
   ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest)))))));
 
 const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
@@ -51,12 +52,3 @@ function attributes(ns: (string | HTMLElement)[]): Record<string, string | undef
         }
       : { class: 'reference' };
 }
-
-export function optimize(opener: string, ns: readonly (string | HTMLElement)[], rest: string): Result<string> {
-  let count = 0;
-  for (let i = 0; i < ns.length - 1; i += 2) {
-    if (ns[i] !== '' || ns[i + 1] !== opener[0]) break;
-    ++count;
-  }
-  return [[opener[0].repeat(opener.length + count)], rest.slice(count)];
-}

package/src/parser/inline/template.ts

@@ -5,7 +5,7 @@ import { escsource, str } from '../source';
 import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const template: TemplateParser = lazy(() => creator(precedence(3, rewrite(
+export const template: TemplateParser = lazy(() => creator(precedence(2, rewrite(
   surround('{{', some(union([bracket, escsource]), '}'), '}}', true),
   source => [[html('span', { class: 'template' }, source.replace(/\x1B/g, ''))], '']))));
 

package/src/parser/inline.test.ts

@@ -143,18 +143,20 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('Di$ney Micro$oft')), [['Di', '$', 'ney', ' ', 'Micro', '$', 'oft'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney, Micro$oft')), [['Di', '$', 'ney', ',', ' ', 'Micro', '$', 'oft'], '']);
       assert.deepStrictEqual(inspect(parser('(((a))')), [['', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((((a))')), [['((', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((((a))')), [['', '((', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((${))}$')), [['', '((', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), [['', '[', '<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['', '[[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[$-1]]]')), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><span><a href="a">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['', '[[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a href="http://host" target="_blank">http://host</a>', '>'], '']);
@@ -165,7 +167,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>', '<em>b<br>c</em>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a href="/">/</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[[', '<em>a<br>b</em>', ']', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['', '[[', '<em>a<br>b</em>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });

package/src/parser/inline.ts

@@ -34,6 +34,7 @@ export import MathParser = InlineParser.MathParser;
 export import ExtensionParser = InlineParser.ExtensionParser;
 export import RubyParser = InlineParser.RubyParser;
 export import LinkParser = InlineParser.LinkParser;
+export import TextLinkParser = InlineParser.TextLinkParser;
 export import HTMLParser = InlineParser.HTMLParser;
 export import InsertionParser = InlineParser.InsertionParser;
 export import DeletionParser = InlineParser.DeletionParser;

package/src/parser/util.ts

@@ -182,24 +182,24 @@ export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>):
     parser,
     trimNodeEnd);
 }
-//export function trimNode(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
-//  return trimNodeStart(trimNodeEnd(nodes));
-//}
-//function trimNodeStart(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
-//  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
-//    if (nodes.length === 1 && typeof node === 'object' && node.className === 'indexer') break;
-//    if (typeof node === 'string') {
-//      const pos = node.length - node.trimStart().length;
-//      if (pos > 0) {
-//        nodes[0] = node.slice(pos);
-//        break;
-//      }
-//    }
-//    nodes.shift();
-//  }
-//  return nodes;
-//}
-export function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
+export function trimNode<T extends HTMLElement | string>(nodes: T[]): T[] {
+  return trimNodeStart(trimNodeEnd(nodes));
+}
+function trimNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
+  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
+    if (nodes.length === 1 && typeof node === 'object' && node.className === 'indexer') break;
+    if (typeof node === 'string') {
+      const pos = node.trimStart().length;
+      if (pos > 0) {
+        nodes[0] = node.slice(-pos) as T;
+        break;
+      }
+    }
+    nodes.shift();
+  }
+  return nodes;
+}
+function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
   const skip = nodes.length > 0 &&
     typeof nodes[nodes.length - 1] === 'object' &&
     nodes[nodes.length - 1]['className'] === 'indexer'