securemark 0.299.1 → 0.299.3

package/src/parser/inline/media.ts

@@ -2,7 +2,7 @@ import { MediaParser } from '../inline';
 import { State, Recursion, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { Flag } from '../node';
-import { union, inits, tails, some, consume, recursion, precedence, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, spend, recursion, precedence, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { uri, option as linkoption, resolve, decode, parse } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
@@ -59,7 +59,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, open(
       text = text.trim();
       if (text === '' || text[0] !== tmp[0]) return;
     }
-    consume(100, context);
+    spend(context, 100);
     if (params.last!.value === Command.Cancel) {
       params.pop();
       return new List([

package/src/parser/inline/ruby.ts

@@ -20,13 +20,12 @@ export const ruby: RubyParser = lazy(() => bind(
       })),
     dup(surround(
       '(', text, ')',
-      false,
-      [3 | Backtrack.ruby])),
+      false)),
   ]),
   ([{ value: texts }, { value: rubies = undefined } = {}], context) => {
     if (rubies === undefined) {
       const head = context.position - context.range;
-      return void setBacktrack(context, 2 | Backtrack.ruby, head);
+      return void setBacktrack(context, 2 | Backtrack.link | Backtrack.ruby, head);
     }
     switch (true) {
       case texts.length >= rubies.length:

package/src/parser/inline.test.ts

@@ -167,7 +167,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('"[% "*"* %]', new Context())), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('"{{""}}', new Context())), [['"', '{', '<a class="url" href="&quot;&quot;">""</a>', '}'], '']);
       assert.deepStrictEqual(inspect(parser, input('[#http://host/(<bdi>)]</bdi>', new Context())), [['<a class="index" href="#index::http://host/(&lt;bdi&gt;)">http://host/<span class="paren">(<span class="invalid">&lt;bdi&gt;</span>)</span></a>', '</bdi', '>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[#@a/http://host/(<bdi>)]</bdi>', new Context())), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/<span class="paren">(<span class="invalid">&lt;bdi&gt;</span>)</span></a>', '</bdi', '>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[#@a/http://host/(<bdi>)]</bdi>', new Context())), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/(&lt;bdi&gt;)</a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[#a|<bdi>]</bdi>', new Context())), [['<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[#a|<bdi>]</bdi>', new Context())), [['[', '<a class="index" href="#index::a|&lt;bdi&gt;">a|<span class="invalid">&lt;bdi&gt;</span></a>', '</bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[*==*]{a}', new Context())), [['<a class="link" href="a">*==*</a>'], '']);

package/src/parser/inline.ts

@@ -135,5 +135,5 @@ export { shortmedia, lineshortmedia } from './inline/shortmedia';
 
 function isAlphabet(char: string): boolean {
   assert(char.length === 1);
-  return 'a' <= char && char <= 'z';
+  return char <= 'z' && 'a' <= char;
 }

package/src/parser/repeat.ts

@@ -1,17 +1,18 @@
 import { Parser, Result, List, Node } from '../combinator/data/parser';
 import { tester } from '../combinator/data/delimiter';
+import { recur } from '../combinator';
 import { Context, Recursion, Command } from './context';
 import { min } from 'spica/alias';
 
 export function repeat<P extends Parser<HTMLElement | string, Context>>(
-  opener: string, after: string | RegExp, closer: string, recursions: readonly Recursion[], parser: P,
+  opener: string, after: string | RegExp, closer: string, recursion: Recursion, parser: P,
   cons: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>, lead: number, follow: number) =>
     List<Node<Parser.Node<P>>>,
   termination?: (acc: List<Node<Parser.Node<P>>>, context: Context, prefix: number, postfix: number, state: boolean) =>
     Result<string | Parser.Node<P>>,
 ): P;
 export function repeat<N extends HTMLElement | string>(
-  opener: string, after: string | RegExp, closer: string, rs: readonly Recursion[], parser: Parser<N>,
+  opener: string, after: string | RegExp, closer: string, recursion: Recursion, parser: Parser<N>,
   cons: (nodes: List<Node<N>>, context: Context, lead: number, follow: number) =>
     List<Node<N>>,
   termination: (acc: List<Node<N>>, context: Context, prefix: number, postfix: number, state: boolean) =>
@@ -35,7 +36,7 @@ export function repeat<N extends HTMLElement | string>(
   const test = tester(after, false);
   return input => {
     const context = input;
-    const { source, position, resources: { recursions } = {} } = context;
+    const { source, position, resources: { recursions } } = context;
     if (!source.startsWith(opener, context.position)) return;
     let nodes = new List<Node<N>>();
     let i = opener.length;
@@ -46,20 +47,11 @@ export function repeat<N extends HTMLElement | string>(
       return;
     }
     let depth = i / opener.length + 1 | 0;
-    if (recursions) for (const recursion of rs) {
-      const rec = min(recursion, recursions.length - 1);
-      if (rec === -1) continue;
-      if (recursions[rec] < depth - 1) throw new Error('Too much recursion');
-      recursions[rec] -= depth;
-    }
+    recur(recursions, recursion, depth, true);
     let state = false;
     let follow = 0;
     for (; i >= opener.length; i -= opener.length, follow -= closer.length) {
-      if (recursions) for (const recursion of rs) {
-        const rec = min(recursion, recursions.length - 1);
-        if (rec === -1) continue;
-        recursions[rec] += 1;
-      }
+      recur(recursions, recursion, -1);
       depth -= 1;
       const lead = i - opener.length;
       if (source.startsWith(closer, context.position)) {
@@ -68,10 +60,10 @@ export function repeat<N extends HTMLElement | string>(
         follow = follow > 0 ? follow : countFollows(source, pos, closer, lead / opener.length | 0);
         nodes = cons(nodes, context, lead, follow);
         if (context.position > pos) {
-          const advance = opener.length * (context.position - pos) / closer.length | 0;
+          const advance = context.position - pos;
           i -= advance;
           follow -= advance;
-          depth -= advance;
+          depth -= advance / closer.length | 0;
         }
         continue;
       }
@@ -100,20 +92,16 @@ export function repeat<N extends HTMLElement | string>(
           nodes = cons(nodes, context, lead, follow);
           state = true;
           if (context.position > pos) {
-            const advance = opener.length * (context.position - pos) / closer.length | 0;
+            const advance = context.position - pos;
             i -= advance;
             follow -= advance;
-            depth -= advance;
+            depth -= advance / closer.length | 0;
           }
           continue;
       }
       break;
     }
-    if (recursions) for (let i = 0; i < depth; ++i) for (const recursion of rs) {
-      const rec = min(recursion, recursions.length - 1);
-      if (rec === -1) continue;
-      recursions[rec] += depth;
-    }
+    recur(recursions, recursion, -depth);
     depth = 0;
     const prefix = i;
     i = 0;

package/src/parser/source/escapable.ts

@@ -2,21 +2,18 @@ import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { Flag } from '../node';
 import { List, Node } from '../../combinator/data/parser';
-import { consume } from '../../combinator';
-import { next } from './text';
+import { spend } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
-const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s\$|:\/\/)/g;
-
 export const escsource: EscapableSourceParser = context => {
-  const { source, position, state } = context;
+  const { source, position } = context;
   if (position === source.length) return;
   const char = source[position];
-  consume(1, context);
+  spend(context, 1);
   context.position += 1;
   switch (char) {
     case Command.Escape:
-      consume(1, context);
+      spend(context, 1);
       context.position += 1;
       return new List([new Node(source.slice(position + 1, position + 2))]);
     case '\\':
@@ -26,7 +23,7 @@ export const escsource: EscapableSourceParser = context => {
         case '\n':
           return new List([new Node(char)]);
         default:
-          consume(1, context);
+          spend(context, 1);
           context.position += 1;
           return new List([new Node(source.slice(position, position + 2))]);
       }
@@ -38,11 +35,37 @@ export const escsource: EscapableSourceParser = context => {
     default:
       assert(char !== '\n');
       if (context.sequential) return new List([new Node(char)]);
-      let i = next(source, position, state, delimiter);
+      let i = seek(source, position);
       assert(i > position);
       i -= position;
-      consume(i - 1, context);
+      spend(context, i - 1);
       context.position += i - 1;
       return new List([new Node(source.slice(position, context.position))]);
   }
 };
+
+function seek(source: string, position: number): number {
+  for (let i = position + 1; i < source.length; ++i) {
+    const char = source[i];
+    switch (char) {
+      case '\\':
+      case '$':
+      case '"':
+      case '`':
+      case ':':
+      case '[':
+      case ']':
+      case '(':
+      case ')':
+      case '{':
+      case '}':
+      case '\r':
+      case '\n':
+        return i;
+      default:
+        continue;
+    }
+    assert(false);
+  }
+  return source.length;
+}

package/src/parser/source/text.ts

@@ -2,7 +2,7 @@ import { TextParser, TxtParser } from '../source';
 import { State, Command } from '../context';
 import { Flag } from '../node';
 import { List, Node } from '../../combinator/data/parser';
-import { union, consume } from '../../combinator';
+import { union, spend } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
 export const nonWhitespace = /[^ \t　]/g;
@@ -12,7 +12,7 @@ export const text: TextParser = input => {
   const { source, position, state } = context;
   if (position === source.length) return;
   const char = source[position];
-  consume(1, context);
+  spend(context, 1);
   context.position += 1;
   switch (char) {
     case Command.Escape:
@@ -25,7 +25,7 @@ export const text: TextParser = input => {
           assert(char !== Command.Escape);
           return new List();
         default:
-          consume(1, context);
+          spend(context, 1);
           context.position += 1;
           return new List([new Node(source.slice(position + 1, context.position))]);
       }
@@ -51,7 +51,7 @@ export const text: TextParser = input => {
         || s && source[i] === '\n';
       i -= position;
       i = lineend ? i : i - +s || 1;
-      consume(i - 1, context);
+      spend(context, i - 1);
       context.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
       if (position === context.position || s && !linestart || lineend) return new List();
@@ -83,28 +83,20 @@ function isWhitespace(char: string, linebreak: boolean): boolean {
   }
 }
 
-export function next(source: string, position: number, state: number, delimiter?: RegExp): number {
-  let index: number;
-  if (delimiter) {
-    delimiter.lastIndex = position + 1;
-    delimiter.test(source);
-    index = delimiter.lastIndex || position;
-  }
-  else {
-    index = seek(source, position, state);
-  }
-  if (index === position || index === source.length) return source.length;
+function next(source: string, position: number, state: number): number {
+  let index= seek(source, position, 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) || delimiter);
-      index += !delimiter && index - 1 > position
+      assert(source.startsWith('%]', index) && isWhitespace(source[index - 1], true));
+      index += index - 1 > position
         ? -1
         : 0;
       break;
     case '[':
-      index += !delimiter && index - 1 > position && source.startsWith(' [|', index - 1)
+      index += index - 1 > position && source.startsWith(' [|', index - 1)
         ? -1
         : 0;
       break;
@@ -122,7 +114,7 @@ export function next(source: string, position: number, state: number, delimiter?
   assert(index > position);
   return index;
 }
-function backToUrlHead(source: string, position: number, index: number): number {
+export function backToUrlHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
   for (let i = index - 1; i >= position; --i) {
@@ -145,7 +137,7 @@ function backToUrlHead(source: string, position: number, index: number): number
     ? delim
     : index;
 }
-function backToEmailHead(source: string, position: number, index: number): number {
+export function backToEmailHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
   for (let i = index - 1; i >= position; --i) {
@@ -171,10 +163,9 @@ function backToEmailHead(source: string, position: number, index: number): numbe
 }
 export 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';
+  if (char < '0' || 'z' < char) return false;
+  if (char <= '9' || 'a' <= char) return true;
+  return 'A' <= char && char <= 'Z';
 }
 
 function seek(source: string, position: number, state: number): number {

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

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

package/src/parser/source/unescapable.ts

@@ -1,22 +1,20 @@
 import { UnescapableSourceParser } from '../source';
-import { Command } from '../context';
+import { State, Command } from '../context';
 import { Flag } from '../node';
 import { List, Node } from '../../combinator/data/parser';
-import { consume } from '../../combinator';
-import { nonWhitespace, canSkip, next } from './text';
+import { spend } from '../../combinator';
+import { nonWhitespace, canSkip, backToUrlHead, backToEmailHead } from './text';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /(?=(?=[\x00-\x7F])[^0-9A-Za-z]|(?<=[\x00-\x7F])[^\x00-\x7F])/g;
-
 export const unescsource: UnescapableSourceParser = context => {
   const { source, position, state } = context;
   if (position === source.length) return;
   const char = source[position];
-  consume(1, context);
+  spend(context, 1);
   context.position += 1;
   switch (char) {
     case Command.Escape:
-      consume(1, context);
+      spend(context, 1);
       context.position += 1;
       return new List([new Node(source.slice(position + 1, position + 2))]);
     case '\r':
@@ -32,11 +30,94 @@ export const unescsource: UnescapableSourceParser = context => {
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length
-        : next(source, position, state, delimiter);
+        : next(source, position, state);
       assert(i > position);
       i -= position;
-      consume(i - 1, context);
+      spend(context, i - 1);
       context.position += i - 1;
       return new List([new Node(source.slice(position, context.position))]);
   }
 };
+
+function next(source: string, position: number, state: number): number {
+  let index= seek(source, position, state);
+  assert(index > position);
+  if (index === source.length) return index;
+  const char = source[index];
+  switch (char) {
+    case ':':
+      index = source.startsWith('//', index + 1)
+        ? backToUrlHead(source, position, index)
+        : index;
+      break;
+    case '@':
+      index = ~state & State.autolink
+        ? backToEmailHead(source, position, index)
+        : index;
+      break;
+  }
+  assert(index > position);
+  return index;
+}
+
+function seek(source: string, position: number, state: number): number {
+  const cat = category(source[position]);
+  for (let i = position + 1; i < source.length; ++i) {
+    const char = source[i];
+    switch (char) {
+      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 '_':
+      case ',':
+      case '.':
+      case ';':
+      case ':':
+      case '!':
+      case '?':
+      case '/':
+      case '|':
+      case '\r':
+      case '\n':
+        return i;
+      case '@':
+      case '#':
+        if (~state & State.autolink) return i;
+        continue;
+      case ':':
+        if (source[i + 1] === '/' && source[i + 2] === '/') return i;
+        continue;
+      default:
+        if (cat && !category(char)) return i;
+        continue;
+    }
+    assert(false);
+  }
+  return source.length;
+}
+
+function category(char: string): boolean {
+  return char <= '\x7E' && '\x21' <= char;
+}