securemark 0.293.2 → 0.293.4

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.test.ts

@@ -15,6 +15,7 @@ describe('Unit: parser/source/escsource', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser('a b c'), ctx), [['a b c'], '']);
       assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
     });
 

package/src/parser/source/escapable.ts

@@ -1,10 +1,10 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
-import { nonWhitespace, isBlank, next } from './text';
+import { next } from './text';
 import { html } from 'typed-dom/dom';
 
-const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s(?:\$)|:\/\/)/g;
+const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s\$|:\/\/)/g;
 
 export const escsource: EscapableSourceParser = ({ context }) => {
   const { source, position } = context;
@@ -38,13 +38,7 @@ export const escsource: EscapableSourceParser = ({ context }) => {
     default:
       assert(char !== '\n');
       if (context.sequential) return [[char]];
-      nonWhitespace.lastIndex = position + 1;
-      const b = isBlank(source, position);
-      let i = b
-        ? nonWhitespace.test(source)
-          ? nonWhitespace.lastIndex - 1
-          : source.length
-        : next(source, position, delimiter);
+      let i = next(source, position, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);

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

@@ -15,6 +15,7 @@ describe('Unit: parser/source/text', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser('a b c'), ctx), [['a b c'], '']);
       assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
       assert.deepStrictEqual(inspect(parser('a\nb'), ctx), [['a', '<br>', 'b'], '']);
     });
@@ -39,8 +40,8 @@ describe('Unit: parser/source/text', () => {
       assert.deepStrictEqual(inspect(parser('   '), ctx), [[], '']);
       assert.deepStrictEqual(inspect(parser(' \n'), ctx), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser('  \n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \\\n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \\\n'), ctx), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser(' \\\n'), ctx), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \\\n'), ctx), [[' ', ' ', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser(' a'), ctx), [[' a'], '']);
       assert.deepStrictEqual(inspect(parser('  a'), ctx), [[' ', ' a'], '']);
       assert.deepStrictEqual(inspect(parser('   a'), ctx), [['  ', ' a'], '']);
@@ -48,8 +49,8 @@ describe('Unit: parser/source/text', () => {
       assert.deepStrictEqual(inspect(parser('a  '), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('a \n'), ctx), [['a', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a  \n'), ctx), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a \\\n'), ctx), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \\\n'), ctx), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a \\\n'), ctx), [['a', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a  \\\n'), ctx), [['a', ' ', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a b'), ctx), [['a b'], '']);
       assert.deepStrictEqual(inspect(parser('a  b'), ctx), [['a', ' b'], '']);
       assert.deepStrictEqual(inspect(parser('a   b'), ctx), [['a', ' b'], '']);

package/src/parser/source/text.ts

@@ -3,8 +3,8 @@ 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;
-export const nonWhitespace = /[\S\r\n]/g;
+//const delimiter = /(?=[\\!@#$&"`\[\](){}<>（）［］｛｝*%|\r\n]|([+~=])\1|\/{3}|\s(?:\\?(?:$|\s)|[$%])|:\/\/)/g;
+export const nonWhitespace = /[^ \t　]/g;
 
 export const text: TextParser = input => {
   const { context } = input;
@@ -38,27 +38,24 @@ export const text: TextParser = input => {
       assert(char !== '\n');
       if (context.sequential) return [[char]];
       nonWhitespace.lastIndex = position + 1;
-      const b = isBlank(source, position);
-      let i = b
+      const s = canSkip(source, position);
+      let i = s
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length
-        : next(source, position, delimiter);
+        : next(source, position);
       assert(i > position);
       const lineend = 0
-        || b && i === source.length
-        || b && source[i] === '\n'
-        || b && source[i] === '\\' && source[i + 1] === '\n';
+        || s && i === source.length
+        || s && source[i] === '\n';
       i -= position;
-      i = lineend ? i : i - +b || 1;
+      i = lineend ? i : i - +s || 1;
       consume(i - 1, context);
       context.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
-      i = linestart && b && i >= 3 ? i - 3 : 0;
-      i += position;
-      return i === context.position || b && !linestart || lineend
+      return position === context.position || s && !linestart || lineend
         ? [[]]
-        : [[source.slice(i, context.position)]];
+        : [[source.slice(position, context.position)]];
   }
 };
 
@@ -70,16 +67,58 @@ 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 canSkip(source: string, position: number): boolean {
+  assert(position < source.length);
+  if (!isWhitespace(source[position], false)) return false;
+  if (position + 1 === source.length) return true;
+  return isWhitespace(source[position + 1], true);
+}
+function isWhitespace(char: string, linebreak: boolean): boolean {
+  switch (char) {
+    case ' ':
+    case '\t':
+    case '　':
+      return true;
+    case '\r':
+    case '\n':
+      return linebreak;
+    default:
+      return false;
+  }
+}
+
+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];
   switch (char) {
+    case '$':
+    case '%':
+    case '*':
+    case '+':
+    case '~':
+    case '=':
+    case '/':
+      index = backToWhitespace(source, position, index);
+      break;
+    case '[':
+      index = source[index + 1] === '|'
+        ? backToWhitespace(source, position, index)
+        : index;
+      break;
     case ':':
-      index = backToUrlHead(source, position, index);
+      index = source.startsWith('//', index + 1)
+        ? backToUrlHead(source, position, index)
+        : index;
       break;
     case '@':
       index = backToEmailHead(source, position, index);
@@ -88,6 +127,12 @@ export function next(source: string, position: number, delimiter: RegExp): numbe
   assert(index > position);
   return index;
 }
+export function backToWhitespace(source: string, position: number, index: number): number {
+  const prev = index - 1;
+  return prev > position && /\s/.test(source[prev])
+    ? prev
+    : index;
+}
 export function backToUrlHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
@@ -143,12 +188,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 +195,115 @@ 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);
+//  }
+//};
+
+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 '\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] === ']') 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 '　':
+            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:
+        continue;
+    }
+    assert(false);
+  }
+  return source.length;
+}

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

@@ -15,6 +15,7 @@ describe('Unit: parser/source/unescapable', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser('a b c'), ctx), [['a', ' b', ' c'], '']);
       assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あいAZaz'], '']);
     });
 

package/src/parser/source/unescapable.ts

@@ -1,7 +1,7 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
-import { nonWhitespace, isBlank, next } from './text';
+import { nonWhitespace, canSkip, next } from './text';
 import { html } from 'typed-dom/dom';
 
 export const delimiter = /(?=(?=[\x00-\x7F])[^0-9A-Za-z]|(?<=[\x00-\x7F])[^\x00-\x7F])/g;
@@ -28,8 +28,7 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
       assert(char !== '\n');
       if (context.sequential) return [[char]];
       nonWhitespace.lastIndex = position + 1;
-      const b = isBlank(source, position);
-      let i = b
+      let i = canSkip(source, position)
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length