securemark 0.293.3 → 0.293.5

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

@@ -4,7 +4,7 @@ import { union, consume, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
 //const delimiter = /(?=[\\!@#$&"`\[\](){}<>（）［］｛｝*%|\r\n]|([+~=])\1|\/{3}|\s(?:\\?(?:$|\s)|[$%])|:\/\/)/g;
-export const nonWhitespace = /[\S\r\n]/g;
+export const nonWhitespace = /[^ \t　]/g;
 
 export const text: TextParser = input => {
   const { context } = input;
@@ -38,29 +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
-        ? source[position + 1] === '\n'
-          ? position + 1
-          : nonWhitespace.test(source)
-            ? nonWhitespace.lastIndex - 1
-            : source.length
+      const s = canSkip(source, position);
+      let i = s
+        ? nonWhitespace.test(source)
+          ? nonWhitespace.lastIndex - 1
+          : source.length
         : 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)]];
   }
 };
 
@@ -72,6 +67,26 @@ export const linebreak: LinebreakParser = focus(/[\r\n]/y, union([
   text,
 ])) as LinebreakParser;
 
+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) {
@@ -86,8 +101,24 @@ export function next(source: string, position: number, delimiter?: RegExp): numb
   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);
@@ -96,39 +127,39 @@ export function next(source: string, position: number, delimiter?: RegExp): numb
   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;
-  let offset = 0;
-  for (let i = index; --i > position;) {
-    index = i;
+  for (let i = index - 1; i >= position; --i) {
     const char = source[i];
     if (state) switch (char) {
       case '.':
       case '+':
       case '-':
         state = false;
-        offset = 1;
         continue;
     }
     if (isAlphanumeric(char)) {
       state = true;
-      offset = 0;
+      index = i;
       continue;
     }
     break;
   }
-  if (index === position + 1 && offset === 0 && isAlphanumeric(source[index - 1])) {
-    return delim;
-  }
-  return index + offset;
+  return index === position
+    ? delim
+    : index;
 }
 export function backToEmailHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
-  let offset = 0;
-  for (let i = index; --i > position;) {
-    index = i;
+  for (let i = index - 1; i >= position; --i) {
     const char = source[i];
     if (state) switch (char) {
       case '_':
@@ -136,22 +167,19 @@ export function backToEmailHead(source: string, position: number, index: number)
       case '+':
       case '-':
         state = false;
-        offset = 1;
         continue;
     }
     if (isAlphanumeric(char)) {
       state = true;
-      offset = 0;
+      index = i;
       continue;
     }
     break;
   }
-  if (index === position + 1 && offset === 0 && isAlphanumeric(source[index - 1])) {
-    return delim;
-  }
-  return index + offset;
+  return index === position
+    ? delim
+    : index;
 }
-
 function isAlphanumeric(char: string): boolean {
   assert(char.length === 1);
   if (char < '0' || '\x7F' < char) return false;
@@ -195,8 +223,6 @@ function isAlphanumeric(char: string): boolean {
 //  }
 //};
 
-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];
@@ -225,7 +251,6 @@ function seek(source: string, position: number): number {
       case '｛':
       case '｝':
       case '*':
-      case '%':
       case '|':
       case '\r':
       case '\n':
@@ -238,68 +263,39 @@ function seek(source: string, position: number): number {
       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 '　':
-      //    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;
+      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:
-        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.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,13 +28,10 @@ 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
-        ? source[position + 1] === '\n'
-          ? position + 1
-          : nonWhitespace.test(source)
-            ? nonWhitespace.lastIndex - 1
-            : source.length
+      let i = canSkip(source, position)
+        ? nonWhitespace.test(source)
+          ? nonWhitespace.lastIndex - 1
+          : source.length
         : next(source, position, delimiter);
       assert(i > position);
       i -= position;

package/src/parser/util.ts

@@ -2,27 +2,8 @@ import { min } from 'spica/alias';
 import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
 import { Parser, Result, Ctx, Node, Context, eval, failsafe } from '../combinator/data/parser';
-import { convert } from '../combinator';
 import { define } from 'typed-dom/dom';
 
-export function linearize<P extends Parser<HTMLElement | string>>(parser: P, trim?: 0 | 1 | -1): P;
-export function linearize<N extends HTMLElement | string>(parser: Parser<N>, trim = 0): Parser<N> {
-  return convert(
-    source => `${
-      trim === 0
-        ? source
-        : trim > 0
-          ? source.at(-1) === '\n'
-            ? source
-            : source + '\n'
-          : source.at(-1) === '\n'
-            ? source.slice(0, -1)
-            : source
-    }`,
-    parser,
-    trim === 0);
-}
-
 export function repeat<P extends Parser<HTMLElement |  string, MarkdownParser.Context>>(symbol: string, parser: P, cons: (nodes: Node<P>[], context: Context<P>) => Node<P>[], termination?: (acc: Node<P>[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
 export function repeat<N extends HTMLElement |  string>(symbol: string, parser: Parser<N>, cons: (nodes: N[], context: MarkdownParser.Context) => N[], termination: (acc: N[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | N, MarkdownParser.Context> = (nodes, context, prefix, postfix) => {
   const acc = [];