securemark 0.300.0 → 0.300.1

package/src/parser/inline/ruby.ts

@@ -3,7 +3,7 @@ import { Input, Backtrack } from '../context';
 import { Parser, Result, List, Node } from '../../combinator/parser';
 import { union, inits, always, backtrack, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
-import { txt } from '../source';
+import { txt, isWhitespace } from '../source';
 import { isNonblankNodeStart } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
@@ -63,8 +63,6 @@ export const ruby: RubyParser = lazy(() => backtrack(bind(
     }
   })));
 
-const delimiter = /[$"`\[\](){}<>（）［］｛｝|]|\\?\r?\n/y;
-
 interface Memory {
   position: number;
   state: boolean;
@@ -72,7 +70,7 @@ interface Memory {
 }
 const text: RubyParser.TextParser = always<Parser<string, Input<Memory>>>([
   (input, output) => {
-    input.sequential = true;
+    input.whitespace = true;
     input.memory = {
       position: 0,
       state: false,
@@ -83,7 +81,7 @@ const text: RubyParser.TextParser = always<Parser<string, Input<Memory>>>([
   () => loop,
   (input, output) => {
     const { memory } = input;
-    input.sequential = false;
+    input.whitespace = false;
     return memory.state || memory.nodes.last!.value.trimStart() !== ''
       ? output.import(memory.nodes)
       : undefined;
@@ -94,10 +92,9 @@ const loop: Result<string, Input<Memory>> = [
     const { source, memory } = input;
     for (let { position } = input; ; position = input.position) {
       if (position === source.length) return Result.skip;
-      delimiter.lastIndex = position;
-      if (delimiter.test(source)) return Result.skip;
+      if (isDelimiter(source, position)) return Result.skip;
       assert(source[position] !== '\n');
-      if (source[position].trimStart() !== '') break;
+      if (!isWhitespace(source[position])) break;
       memory.state ||= memory.nodes.last!.value.trimStart() !== '';
       memory.nodes.push(new Node(''));
       input.position += 1;
@@ -124,3 +121,43 @@ function* zip<N extends Node<unknown>>(a: List<N>, b: List<N>): Iterable<[N | un
     yield [ra.value, rb.value];
   }
 }
+
+function isDelimiter(source: string, position: number): boolean {
+  switch (source[position]) {
+    case '$':
+    case '"':
+    case '`':
+    case '[':
+    case ']':
+    case '(':
+    case ')':
+    case '{':
+    case '}':
+    case '<':
+    case '>':
+    case '（':
+    case '）':
+    case '［':
+    case '］':
+    case '｛':
+    case '｝':
+    case '|':
+      return true;
+    case '\\':
+      switch (source[position + 1]) {
+        case '\r':
+          return source[position + 2] === '\n';
+        case '\n':
+          return true;
+        default:
+          return false;
+      }
+    case '\r':
+      return source[position + 1] === '\n';
+    case '\n':
+      return true;
+    default:
+      return false;
+  }
+  assert(false);
+}

package/src/parser/inline/template.ts

@@ -25,15 +25,15 @@ export const template: TemplateParser = lazy(() => backtrack(surround(
         input.source.slice(input.position - input.range, input.position)))))));
 
 const bracket: TemplateParser.BracketParser = lazy(() => union([
-  surround(str('('), recursion(Recursion.terminal, some(union([bracket, escsource]), ')')), str(')'),
+  surround(str('('), recursion(Recursion.bracket, some(union([bracket, escsource]), ')')), str(')'),
     true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
-  surround(str('['), recursion(Recursion.terminal, some(union([bracket, escsource]), ']')), str(']'),
+  surround(str('['), recursion(Recursion.bracket, some(union([bracket, escsource]), ']')), str(']'),
     true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
-  surround(str('{'), recursion(Recursion.terminal, some(union([bracket, escsource]), '}')), str('}'),
+  surround(str('{'), recursion(Recursion.bracket, some(union([bracket, escsource]), '}')), str('}'),
     true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
   surround(
     str('"'),
-    precedence(2, recursion(Recursion.terminal, some(escsource, /["\n]/y, [['"', 2], ['\n', 3]]))),
+    precedence(2, recursion(Recursion.bracket, some(escsource, /["\n]/y, [['"', 2], ['\n', 3]]))),
     str('"'),
     true, [], undefined, ([as, bs], _, output) => bs && output.import(as.import(bs as List<Node<string>>))),
 ]));

package/src/parser/source/escapable.ts

@@ -34,7 +34,6 @@ export const escsource: EscapableSourceParser = (input, output) => {
       return output.append(new Node(html('br'), Flag.blank));
     default:
       assert(char !== '\n');
-      if (input.sequential) return output.append(new Node(char));
       let i = seek(source, position);
       assert(i > position);
       i -= position;

package/src/parser/source/text.ts

@@ -3,6 +3,7 @@ import { Result, Node } from '../../combinator/parser';
 import { union, spend } from '../../combinator';
 import { State, Command } from '../context';
 import { Flag } from '../node';
+import { isWhitespace } from './whitespace';
 import { html } from 'typed-dom/dom';
 
 export const nonWhitespace = /[^ \t　]/g;
@@ -35,14 +36,13 @@ export const text: TextParser = (input, output) => {
       return output.append(new Node(html('br'), Flag.blank));
     default:
       assert(char !== '\n');
-      if (input.sequential) return output.append(new Node(char));
       nonWhitespace.lastIndex = position + 1;
       const s = canSkip(source, position);
       let i = s
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length
-        : next(source, position, state);
+        : next(source, position, input.whitespace, state);
       assert(i > position);
       const lineend = 0
         || s && i === source.length
@@ -68,28 +68,15 @@ export function canSkip(source: string, position: number): boolean {
   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;
-  }
-}
 
-function next(source: string, position: number, state: number): number {
-  let index= seek(source, position, state);
+function next(source: string, position: number, space: boolean, state: number): number {
+  let index= seek(source, position, space, state);
   assert(index > position);
   if (index === source.length) return index;
   const char = source[index];
   switch (char) {
     case '%':
-      assert(source.startsWith('%]', index) && isWhitespace(source[index - 1], true));
+      assert(source.startsWith('%]', index) && isWhitespace(source[index - 1]));
       index += index - 1 > position
         ? -1
         : 0;
@@ -167,7 +154,7 @@ export function isAlphanumeric(char: string): boolean {
   return 'A' <= char && char <= 'Z';
 }
 
-function seek(source: string, position: number, state: number): number {
+function seek(source: string, position: number, space: boolean, state: number): number {
   for (let i = position + 1; i < source.length; ++i) {
     const char = source[i];
     switch (char) {
@@ -208,7 +195,7 @@ function seek(source: string, position: number, state: number): number {
         if (source[i + 1] === char && source[i + 2] === char) return i;
         continue;
       case '%':
-        if (source[i + 1] === ']' && isWhitespace(source[i - 1], true)) return i;
+        if (source[i + 1] === ']' && isWhitespace(source[i - 1])) return i;
         continue;
       case ':':
         if (source[i + 1] === '/' && source[i + 2] === '/') return i;
@@ -216,30 +203,14 @@ function seek(source: string, position: number, state: number): number {
       case '&':
         if (source[i + 1] !== ' ') 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:
+        if (!isWhitespace(char)) continue;
+        if (space) return i;
+        if (i + 1 === source.length) return i;
+        if (isWhitespace(source[i + 1])) return i;
+        if (source[i + 1] !== '\\') continue;
+        if (i + 2 === source.length) return i;
+        if (isWhitespace(source[i + 2])) return i;
         continue;
     }
     assert(false);

package/src/parser/source/unescapable.ts

@@ -24,7 +24,6 @@ export const unescsource: UnescapableSourceParser = (input, output) => {
       return output.append(new Node(html('br'), Flag.blank));
     default:
       assert(char !== '\n');
-      if (input.sequential) return output.append(new Node(char));
       nonWhitespace.lastIndex = position + 1;
       let i = canSkip(source, position)
         ? nonWhitespace.test(source)

package/src/parser/source/whitespace.ts

@@ -0,0 +1,36 @@
+// https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5Cp%7BWhite_Space%7D&g=&i=
+// https://en.wikipedia.org/wiki/Whitespace_character
+// https://en.wikipedia.org/wiki/Newline
+export function isWhitespace(char: string, linebreak: boolean = true): boolean {
+  switch (char) {
+    case '\u0009':
+    case '\u000B':
+    case '\u000C':
+    case '\u0020':
+    case '\u0085':
+    case '\u00A0':
+    case '\u1680':
+    case '\u2000':
+    case '\u2001':
+    case '\u2002':
+    case '\u2003':
+    case '\u2004':
+    case '\u2005':
+    case '\u2006':
+    case '\u2007':
+    case '\u2008':
+    case '\u2009':
+    case '\u200A':
+    case '\u2028':
+    case '\u2029':
+    case '\u202F':
+    case '\u205F':
+    case '\u3000':
+      return true;
+    case '\u000A':
+    case '\u000D':
+      return linebreak;
+    default:
+      return false;
+  }
+}

package/src/parser/source.ts

@@ -15,4 +15,5 @@ export { text, txt } from './source/text';
 export { escsource } from './source/escapable';
 export { unescsource } from './source/unescapable';
 export { str, strs } from './source/str';
+export { isWhitespace } from './source/whitespace';
 export { contentline, emptyline, emptysegment, anyline } from './source/line';

package/src/parser/visibility.ts

@@ -3,6 +3,7 @@ import { Input, Command } from './context';
 import { Flag } from './node';
 import { always, fmap } from '../combinator';
 import { invisibleBlankHTMLEntityNames } from '../api/normalize';
+import { isWhitespace } from './source';
 
 namespace blank {
   export const line = new RegExp(
@@ -102,7 +103,7 @@ function isNonblank({ value: node, flags }: Node<HTMLElement | string>, strpos?:
     case '\n':
       return false;
     default:
-      return str.trimStart() !== '';
+      return !isWhitespace(str.trimStart());
   }
 }