securemark 0.293.1 → 0.293.3

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,7 +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('09あいAZaz'), ctx), [['09', 'あいAZaz'], '']);
+      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
     });
 
     it('space', () => {

package/src/parser/source/escapable.ts

@@ -2,9 +2,10 @@ import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
 import { nonWhitespace, isBlank, next } from './text';
-import { delimiter } from './unescapable';
 import { html } from 'typed-dom/dom';
 
+const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s(?:\$)|:\/\/)/g;
+
 export const escsource: EscapableSourceParser = ({ context }) => {
   const { source, position } = context;
   if (position === source.length) return;
@@ -40,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 = /(?=[\\!@#$&"`\[\](){}<>（）［］｛｝*%|+~=/]|\s(?:\\?(?:$|\s)|[$*%|]|([+~=])\1)|\/{3}|:\/\/|\n)/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];
@@ -85,16 +93,6 @@ export function next(source: string, position: number, delimiter: RegExp): numbe
       index = backToEmailHead(source, position, index);
       break;
   }
-  if (index > position + 1) switch (char) {
-    case '*':
-    case '+':
-    case '~':
-    case '=':
-    case '/':
-    case '%':
-    case '|':
-      index -= /\s/.test(source[index - 1]) ? 1 : 0;
-  }
   assert(index > position);
   return index;
 }
@@ -154,15 +152,154 @@ 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);
-}
-export function isAlphanumeric(char: string): boolean {
+function isAlphanumeric(char: string): boolean {
   assert(char.length === 1);
   if (char < '0' || '\x7F' < char) return false;
   return '0' <= char && char <= '9'
       || '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;