securemark 0.293.2 → 0.293.3

package/src/parser/inline/math.ts

@@ -11,14 +11,14 @@ export const math: MathParser = lazy(() => rewrite(
   union([
     surround(
       /\$(?={)/y,
-      precedence(5, bracket),
+      precedence(4, bracket),
       '$',
       false, undefined, undefined, [3 | Backtrack.bracket]),
     surround(
       /\$(?![\s{}])/y,
       precedence(2, some(union([
         some(escsource, /\s?\$|[`"{}\n]/y),
-        precedence(5, bracket),
+        precedence(4, bracket),
       ]))),
       /\$(?![-0-9A-Za-z])/y,
       false, undefined, undefined, [3 | Backtrack.bracket]),

package/src/parser/inline/media.ts

@@ -87,7 +87,8 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
     el.setAttribute('alt', text);
     if (!sanitize(el, uri)) return [[el]];
     assert(!el.matches('.invalid'));
-    define(el, attributes('media', optspec, params));
+    const [attrs, linkparams] = attributes('media', optspec, params);
+    define(el, attrs);
     assert(el.matches('img') || !el.matches('.invalid'));
     // Awaiting the generic support for attr().
     if (el.hasAttribute('aspect-ratio')) {
@@ -103,7 +104,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
         context.position = position;
         return [define(link, { class: null, target: '_blank' }, [el])];
       })
-      (subinput(`{ ${INSECURE_URI}${params.join('')} }`, context));
+      (subinput(`{ ${INSECURE_URI}${linkparams.join('')} }`, context));
   })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recursion.terminal, union([

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

@@ -17,7 +17,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[]]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[["]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[(]]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[[<bdi>]]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[[[%]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[ ]]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[ [a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[[\n]]'), ctx), undefined);

package/src/parser/inline/remark.ts

@@ -9,8 +9,8 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const remark: RemarkParser = lazy(() => fallback(surround(
   str(/\[%(?=\s)/y),
-  precedence(4, recursion(Recursion.inline,
-  some(union([inline]), /\s%\]/y, [[/\s%\]/y, 4]]))),
+  precedence(3, recursion(Recursion.inline,
+  some(union([inline]), /\s%\]/y, [[/\s%\]/y, 3]]))),
   close(text, str(`%]`)), true,
   ([as, bs = [], cs]) => [[
     html('span', { class: 'remark' }, [

package/src/parser/inline/template.ts

@@ -34,7 +34,7 @@ const bracket: TemplateParser.BracketParser = lazy(() => union([
     undefined, () => [[]], [3 | Backtrack.escbracket]),
   surround(
     str('"'),
-    precedence(2, recursion(Recursion.terminal, some(escsource, '"', [['"', 2, false]]))),
+    precedence(2, recursion(Recursion.terminal, some(escsource, /["\n]/y, [['"', 2], ['\n', 3]]))),
     str('"'),
     true,
     ([as, bs = [], cs], context) =>

package/src/parser/inline.test.ts

@@ -22,7 +22,7 @@ describe('Unit: parser/inline', () => {
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('あ（Ａ）'), ctx), [['あ', '（', 'Ａ', '）'], '']);
       assert.deepStrictEqual(inspect(parser('あ（い）'), ctx), [['あ', '<span class="paren">（い）</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('* a*'), ctx), [['*', ' a', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('* a*'), ctx), [['* a', '*'], '']);
       assert.deepStrictEqual(inspect(parser('** a**'), ctx), [['**', ' a', '**'], '']);
       assert.deepStrictEqual(inspect(parser('*** a***'), ctx), [['***', ' a', '***'], '']);
       assert.deepStrictEqual(inspect(parser('**** a****'), ctx), [['****', ' a', '****'], '']);
@@ -82,19 +82,19 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*++ a ++*'), ctx), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++  a  ++*'), ctx), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*<bdi>`a`</bdi>*'), ctx), [['<em><bdi><code data-src="`a`">a</code></bdi></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a"\nb*'), ctx), [['*', 'a', '"', '<br>', 'b', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('*a"\nb*'), ctx), [['<em>a"<br>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a"\n"("b*'), ctx), [['<em>a"<br>"("b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('"*a\nb*'), ctx), [['"', '<em>a<br>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('"*a\n""b*'), ctx), [['"', '<em>a<br>""b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a\nb*'), ctx), [['"', '*', 'a', '<br>', 'b', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a\n""b*'), ctx), [['"', '*', 'a', '<br>', '"', '"', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"a\n"*b"c*'), ctx), [['"', 'a', '<br>', '"', '*', 'b', '"', 'c', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('"*a**b\nc**"("*'), ctx), [['"', '<em>a<strong>b<br>c</strong>"("</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>a"\nb</bdi>'), ctx), [['<bdi>a"<br>b</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('"<bdi>"a\n""b</bdi>"'), ctx), [['"', '<bdi>"a<br>""b</bdi>', '"'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a**b\nc**"("*'), ctx), [['"', '*', 'a', '**', 'b', '<br>', 'c', '**', '"', '(', '"', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a"\nb %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a"<br>b %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('"<bdi>"a\n""b</bdi>"'), ctx), [['"', '<span class="invalid">&lt;bdi&gt;</span>', '"', 'a', '<br>', '"', '"', 'b', '</bdi', '>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>*<bdi>a</bdi>*</bdi>'), ctx), [['<bdi><em><bdi>a</bdi></em></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>((<bdi>((a))</bdi>))</bdi>'), ctx), [['<bdi><sup class="annotation"><span><bdi><span class="paren">((a))</span></bdi></span></sup></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>'), ctx), [['<bdi><sup class="reference"><span><bdi>[[a]]</bdi></span></sup></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>[#</bdi>]'), ctx), [['<bdi>[#</bdi>', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('"<bdi>("")</bdi>'), ctx), [['"', '<bdi><span class="paren">("")</span></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>[#</bdi>]'), ctx), [['<span class="invalid">&lt;bdi&gt;[#&lt;/bdi&gt;]</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('"<bdi>("")</bdi>'), ctx), [['"', '<span class="invalid">&lt;bdi&gt;(</span>', '"', '"', ')', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser('++\na\n++\n~~\nb\n~~\nc'), ctx), [['<ins><br>a</ins>', '<br>', '<del><br>b</del>', '<br>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]'), ctx), [['[', '<a class="account" href="/@a">@a</a>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[#1][#2]'), ctx), [['<a class="index" href="#index::1">1</a>', '<a class="index" href="#index::2">2</a>'], '']);
@@ -121,11 +121,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('{}'), ctx), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a}'), ctx), [['<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('{{a}}'), ctx), [['<span class="template">{{a}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{}'), ctx), [['!', '{', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{a}'), ctx), [['!', '<a class="url" href="a">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{{a}}'), ctx), [['!', '<span class="template">{{a}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!{{{a}}}'), ctx), [['!', '<span class="template">{{{a}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\r!!{a}'), ctx), [['!', '!', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!{}'), ctx), [['!', '{', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('!{a}'), ctx), [['!', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('!{{a}}'), ctx), [['!', '<span class="template">{{a}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('!{{{a}}}'), ctx), [['!', '<span class="template">{{{a}}}</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('!!{a}'), ctx), [['!', '!', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('${a}'), ctx), [['$', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('${{a}}'), ctx), [['$', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${{{a}}}'), ctx), [['$', '<span class="template">{{{a}}}</span>'], '']);
@@ -167,8 +167,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('"{{""}}'), ctx), [['"', '{', '{', '"', '"', '}', '}'], '']);
       assert.deepStrictEqual(inspect(parser('[#http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::http://host/(&lt;bdi&gt;)">http://host/(&lt;bdi&gt;)</a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser('[#@a/http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/(&lt;bdi&gt;)</a>', '</bdi', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a|<bdi>]</bdi>'), ctx), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '|', '<bdi>]</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[#a|<bdi>]</bdi>'), ctx), [['[', '[', '<a class="hashtag" href="/hashtags/a">#a</a>', '|', '<bdi>]</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a|<bdi>]</bdi>'), ctx), [['<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[#a|<bdi>]</bdi>'), ctx), [['[', '<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
     });
 
     it('uri', () => {

package/src/parser/inline.ts

@@ -53,70 +53,69 @@ export const inline: InlineParser = lazy(() => union([
   input => {
     const { context: { source, position } } = input;
     if (position === source.length) return;
-    switch (source.slice(position, position + 2)) {
-      case '((':
-        return annotation(input)
-            || bracket(input);
-      case '[[':
-        return reference(input)
-            || textlink(input)
-            || bracket(input);
-      case '{{':
-        return template(input)
-            || bracket(input);
-      case '[%':
-        return remark(input)
-            || textlink(input)
-            || bracket(input);
-      case '[#':
-      case '[$':
-      case '[:':
-      case '[^':
-      case '[|':
-        return extension(input)
-            || textlink(input)
-            || bracket(input);
-      case '${':
-        return math(input);
-      case '++':
-        return insertion(input);
-      case '~~':
-        return deletion(input);
-      case '==':
-        return mark(input);
-      case '//':
-        return italic(input);
-      case '**':
-        return emstrong(input)
-            || strong(input)
-            || stars(input);
-    }
     switch (source[position]) {
+      case '(':
+        if (source[position + 1] === '(') return annotation(input) || bracket(input);
+        return bracket(input);
       case '[':
+        switch (source[position + 1]) {
+          case '[':
+            return reference(input)
+                || textlink(input)
+                || bracket(input);
+          case '%':
+            return remark(input)
+                || textlink(input)
+                || bracket(input);
+          case '#':
+          case '$':
+          case ':':
+          case '^':
+          case '|':
+            return extension(input)
+                || textlink(input)
+                || bracket(input);
+        }
         return textlink(input)
             || ruby(input)
             || bracket(input);
       case '{':
+        if (source[position + 1] === '{') return template(input) || bracket(input);
         return textlink(input)
             || bracket(input);
+      case '"':
+      case '（':
+      case '［':
+      case '｛':
+        return bracket(input);
       case '<':
         return html(input);
       case '$':
+        if (source[position + 1] === '{') return math(input);
         return extension(input)
             || math(input);
+      case '+':
+        if (source[position + 1] === '+') return insertion(input);
+        break;
+      case '~':
+        if (source[position + 1] === '~') return deletion(input);
+        break;
+      case '=':
+        if (source[position + 1] === '=') return mark(input);
+        break;
+      case '/':
+        if (source[position + 1] === '/' && source[position + 2] === '/') return italic(input);
+        break;
+      case '*':
+        return source[position + 1] === '*'
+          ? source[position + 2] === '*'
+            ? emstrong(input) || stars(input)
+            : strong(input) || stars(input)
+          : emphasis(input);
       case '`':
         return code(input);
-      case '*':
-        return emphasis(input)
-            || stars(input);
       case '&':
         return htmlentity(input);
-      case '(':
-      case '（':
-      case '［':
-      case '｛':
-      case '"':
-        return bracket(input);
     }
   },
   autolink,

package/src/parser/segment.ts

@@ -17,19 +17,19 @@ const parser: SegmentParser = union([
   input => {
     const { context: { source, position } } = input;
     if (position === source.length) return;
-    switch (source.slice(position, position + 3)) {
-      case '~~~':
-        return extension(input);
-      case '```':
-        return codeblock(input);
-    }
-    switch (source.slice(position, position + 2)) {
-      case '$$':
-        return mathblock(input);
-      case '[$':
-        return extension(input);
-    }
     switch (source[position]) {
+      case '`':
+        if (source.startsWith('```', position)) return codeblock(input);
+        break;
+      case '~':
+        if (source.startsWith('~~~', position)) return extension(input);
+        break;
+      case '$':
+        if (source[position + 1] === '$') return mathblock(input);
+        break;
+      case '[':
+        if (source[position + 1] === '$') return extension(input);
+        break;
       case '#':
         return heading(input);
       case '$':

package/src/parser/source/escapable.ts

@@ -41,9 +41,11 @@ export const escsource: EscapableSourceParser = ({ context }) => {
       nonWhitespace.lastIndex = position + 1;
       const b = isBlank(source, position);
       let i = b
-        ? nonWhitespace.test(source)
-          ? nonWhitespace.lastIndex - 1
-          : source.length
+        ? source[position + 1] === '\n'
+          ? position + 1
+          : nonWhitespace.test(source)
+            ? nonWhitespace.lastIndex - 1
+            : source.length
         : next(source, position, delimiter);
       assert(i > position);
       i -= position;

package/src/parser/source/text.ts

@@ -3,7 +3,7 @@ import { Command } from '../context';
 import { union, consume, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /(?=[\\!@#$&"`\[\](){}<>（）［］｛｝*%|\r\n]|([+~=])\1|\/{3}|\s(?:\\?(?:$|\s)|[$%])|:\/\/)/g;
+//const delimiter = /(?=[\\!@#$&"`\[\](){}<>（）［］｛｝*%|\r\n]|([+~=])\1|\/{3}|\s(?:\\?(?:$|\s)|[$%])|:\/\/)/g;
 export const nonWhitespace = /[\S\r\n]/g;
 
 export const text: TextParser = input => {
@@ -40,10 +40,12 @@ export const text: TextParser = input => {
       nonWhitespace.lastIndex = position + 1;
       const b = isBlank(source, position);
       let i = b
-        ? nonWhitespace.test(source)
-          ? nonWhitespace.lastIndex - 1
-          : source.length
-        : next(source, position, delimiter);
+        ? source[position + 1] === '\n'
+          ? position + 1
+          : nonWhitespace.test(source)
+            ? nonWhitespace.lastIndex - 1
+            : source.length
+        : next(source, position);
       assert(i > position);
       const lineend = 0
         || b && i === source.length
@@ -70,10 +72,16 @@ export const linebreak: LinebreakParser = focus(/[\r\n]/y, union([
   text,
 ])) as LinebreakParser;
 
-export function next(source: string, position: number, delimiter: RegExp): number {
-  delimiter.lastIndex = position + 1;
-  delimiter.test(source);
-  let index = delimiter.lastIndex;
+export function next(source: string, position: number, delimiter?: RegExp): number {
+  let index: number;
+  if (delimiter) {
+    delimiter.lastIndex = position + 1;
+    delimiter.test(source);
+    index = delimiter.lastIndex;
+  }
+  else {
+    index = seek(source, position);
+  }
   if (index === 0) return source.length;
   assert(index > position);
   const char = source[index];
@@ -144,11 +152,6 @@ export function backToEmailHead(source: string, position: number, index: number)
   return index + offset;
 }
 
-const blank = /\s(?:$|\s|\\\n)/y;
-export function isBlank(source: string, position: number): boolean {
-  blank.lastIndex = position;
-  return blank.test(source);
-}
 function isAlphanumeric(char: string): boolean {
   assert(char.length === 1);
   if (char < '0' || '\x7F' < char) return false;
@@ -156,3 +159,147 @@ function isAlphanumeric(char: string): boolean {
       || 'a' <= char && char <= 'z'
       || 'A' <= char && char <= 'Z';
 }
+
+//const dict = new class {
+//  constructor() {
+//    [
+//      '\\',
+//      '!',
+//      '@',
+//      '#',
+//      '$',
+//      '&',
+//      '"',
+//      '`',
+//      '[',
+//      ']',
+//      '(',
+//      ')',
+//      '{',
+//      '}',
+//      '<',
+//      '>',
+//      '（',
+//      '）',
+//      '［',
+//      '］',
+//      '｛',
+//      '｝',
+//      '*',
+//      '%',
+//      '|',
+//      '\r',
+//      '\n',
+//    ].forEach(c =>
+//      this[c.charCodeAt(0)] = undefined);
+//  }
+//};
+
+const delimiter = /\s(?:\\?(?:$|\s)|[$%])/y;
+
+function seek(source: string, position: number): number {
+  for (let i = position + 1; i < source.length; ++i) {
+    const fst = source[i];
+    //if (fst.charCodeAt(0) in dict) return i;
+    switch (fst) {
+      case '\\':
+      case '!':
+      case '@':
+      case '#':
+      case '$':
+      case '&':
+      case '"':
+      case '`':
+      case '[':
+      case ']':
+      case '(':
+      case ')':
+      case '{':
+      case '}':
+      case '<':
+      case '>':
+      case '（':
+      case '）':
+      case '［':
+      case '］':
+      case '｛':
+      case '｝':
+      case '*':
+      case '%':
+      case '|':
+      case '\r':
+      case '\n':
+        return i;
+      case '+':
+      case '~':
+      case '=':
+        if (source[i + 1] === fst) return i;
+        continue;
+      case '/':
+        if (source[i + 1] === fst && source[i + 2] === fst) return i;
+        continue;
+      case ':':
+        if (source[i + 1] === '/' && source[i + 2] === '/') return i;
+        continue;
+      //case ' ':
+      //case '\t':
+      //case '　':
+      //  if (i + 1 === source.length) return i;
+      //  switch (source[i + 1]) {
+      //    case ' ':
+      //    case '\t':
+      //    case '\r':
+      //    case '\n':
+      //    case '　':
+      //    case '$':
+      //    case '%':
+      //      return i;
+      //    case '\\':
+      //      if (i + 2 === source.length) return i;
+      //      switch (source[i + 2]) {
+      //        case ' ':
+      //        case '\t':
+      //        case '\r':
+      //        case '\n':
+      //        case '　':
+      //          return i;
+      //      }
+      //  }
+      //  continue;
+      default:
+        delimiter.lastIndex = i;
+        if (delimiter.test(source)) return i;
+        continue;
+    }
+    assert(false);
+  }
+  return source.length;
+}
+
+const blank = /\s(?:$|\s|\\\n)/y;
+export function isBlank(source: string, position: number): boolean {
+  blank.lastIndex = position;
+  return blank.test(source);
+  assert(position < source.length);
+  if (!isWhitespace(source[position])) return false;
+  if (position + 1 === source.length) return true;
+  const snd = source[position + 1];
+  if (isWhitespace(snd)) return true;
+  if (position + 2 === source.length) return false;
+  if (snd === '\\' && source[position + 2] === '\n') return true;
+  return false;
+}
+const whitespace = /\s/;
+export function isWhitespace(char: string): boolean {
+  whitespace;
+  switch (char) {
+    case ' ':
+    case '\t':
+    case '\r':
+    case '\n':
+    case '　':
+      return true
+    default:
+      return false;
+  }
+}

package/src/parser/source/unescapable.ts

@@ -30,9 +30,11 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
       nonWhitespace.lastIndex = position + 1;
       const b = isBlank(source, position);
       let i = b
-        ? nonWhitespace.test(source)
-          ? nonWhitespace.lastIndex - 1
-          : source.length
+        ? source[position + 1] === '\n'
+          ? position + 1
+          : nonWhitespace.test(source)
+            ? nonWhitespace.lastIndex - 1
+            : source.length
         : next(source, position, delimiter);
       assert(i > position);
       i -= position;