securemark 0.300.0 → 0.300.2

package/src/parser/block/extension/placeholder.ts

@@ -7,13 +7,13 @@ import { html } from 'typed-dom/dom';
 const opener = /(~{3,})(?!~)[^\r\n]*(?:$|\r?\n)/y;
 
 export const segment: ExtensionParser.PlaceholderParser.SegmentParser = block(
-  fence(opener, false, 300));
+  fence(opener, false));
 
 export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(
-  fence(opener, false, 300, false), false);
+  fence(opener, false, false), false);
 
 export const placeholder: ExtensionParser.PlaceholderParser = block(inits([
-  fence(opener, true, 300),
+  fence(opener, true),
   (_, output) => {
     const [body, overflow, closer, opener, delim] = unwrap(output.pop()) as string[];
     return output.append(
@@ -28,6 +28,6 @@ export const placeholder: ExtensionParser.PlaceholderParser = block(inits([
               overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
                 'Invalid argument'),
         },
-        `${opener}${body}${overflow || closer}`)));
+        `${opener}${body}${closer}${overflow}`)));
   },
 ]));

package/src/parser/block/extension/table.test.ts

@@ -10,7 +10,6 @@ describe('Unit: parser/block/extension/table', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser, input('~~~table a\n-\n~~~')), [['<pre class="invalid" translate="no">~~~table a\n-\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~table\n0${'\n'.repeat(10001)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('data', () => {

package/src/parser/block/extension/table.ts

@@ -17,14 +17,8 @@ import CellParser = TableParser.CellParser;
 
 const opener = /(~{3,})table(?:\/(\S+))?(?!\S)([^\r\n]*)(?:$|\r?\n)/y;
 
-export const segment: TableParser.SegmentParser = block(
-  fence(opener, false, 10000));
-
-export const segment_: TableParser.SegmentParser = block(
-  fence(opener, false, 10000, false), false);
-
 export const table: TableParser = block(inits([
-  fence(opener, true, 10000),
+  fence(opener, true),
   (_, output) => {
     const [body, overflow, closer, opener, delim, type, param] = unwrap(output.pop()) as string[];
     if (!closer || overflow || param.trimStart()) return output.append(
@@ -37,7 +31,7 @@ export const table: TableParser = block(inits([
           !closer ? `Missing the closing delimiter "${delim}"` :
             overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
               'Invalid argument'),
-      }, `${opener}${body}${overflow || closer}`)));
+      }, `${opener}${body}${closer}${overflow}`)));
     switch (type) {
       case undefined:
       case 'grid':

package/src/parser/block/extension.ts

@@ -2,7 +2,7 @@ import { ExtensionParser } from '../block';
 import { union, lazy } from '../../combinator';
 import { segment as seg_fig } from './extension/fig';
 import { figure, segment as seg_figure } from './extension/figure';
-import { table, segment as seg_table } from './extension/table';
+import { table } from './extension/table';
 import { message } from './extension/message';
 import { aside } from './extension/aside';
 import { example } from './extension/example';
@@ -11,7 +11,6 @@ import { placeholder, segment as seg_placeholder } from './extension/placeholder
 export const segment: ExtensionParser.SegmentParser = union([
   seg_fig,
   seg_figure,
-  seg_table,
   seg_placeholder,
 ]);
 

package/src/parser/block/mathblock.test.ts

@@ -25,7 +25,6 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser, input('$$$\n$$')), [['<pre class="invalid" translate="no">$$$\n$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$$$\n$$$')), [['<pre class="invalid" translate="no">$$$\n$$$</pre>'], '']);
       assert.deepStrictEqual(inspect(parser, input(' $$\n$$')), undefined);
-      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(301)}$$`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('basic', () => {
@@ -40,7 +39,6 @@ describe('Unit: parser/block/mathblock', () => {
       assert.deepStrictEqual(inspect(parser, input('$$\n$$\n\n$$')), [['<div class="math" translate="no">$$\n$$</div>'], '\n$$']);
       assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n$$')), [['<div class="math" translate="no">$$\n$$$\n$$</div>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$$\n$$$\n\n$$')), [['<div class="math" translate="no">$$\n$$$\n\n$$</div>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`$$\n0${'\n'.repeat(300)}$$`), '>'), [['<div class="math" translate="no">'], '']);
     });
 
   });

package/src/parser/block/mathblock.ts

@@ -7,13 +7,13 @@ import { html } from 'typed-dom/dom';
 const opener = /(\${2,})(?!\$)([^\r\n]*)(?:$|\r?\n)/y;
 
 export const segment: MathBlockParser.SegmentParser = block(
-  fence(opener, false, 300));
+  fence(opener, false));
 
 export const segment_: MathBlockParser.SegmentParser = block(
-  fence(opener, false, 300, false), false);
+  fence(opener, false, false), false);
 
 export const mathblock: MathBlockParser = block(inits([
-  fence(opener, true, 300),
+  fence(opener, true),
   ({ caches: { math: cache = undefined } = {} }, output) => {
     const [body, overflow, closer, opener, delim, param] = unwrap(output.pop()) as string[];
     return output.append(
@@ -32,6 +32,6 @@ export const mathblock: MathBlockParser = block(inits([
                     overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
                       'Invalid argument'),
             },
-            `${opener}${body}${overflow || closer}`)));
+            `${opener}${body}${closer}${overflow}`)));
   },
 ]));

package/src/parser/context.ts

@@ -8,13 +8,14 @@ export function input(source: string, input: Input = new Input()): Input {
 export class Input<M extends object = object> extends Ipt<M> {
   constructor(
     options: Partial<Input> = {},
+    source?: string,
   ) {
     super(options);
     const {
       segment,
       header,
       local,
-      sequential,
+      whitespace,
       host,
       url,
       id,
@@ -22,20 +23,21 @@ export class Input<M extends object = object> extends Ipt<M> {
       caches,
       test,
     } = options;
+    this.source = source ?? options.source ?? '';
     this.resources ??= {
       clock: -1,
       interval: 200,
       recursions: [
-        10 || Recursion.scope,
+        10 || Recursion.document,
         100 || Recursion.block,
         100 || Recursion.inline,
-        100 || Recursion.terminal,
+        100 || Recursion.bracket,
       ],
     };
     this.segment = segment ?? Segment.unknown;
     this.header = header ?? true;
     this.local = local ?? false;
-    this.sequential = sequential ?? false;
+    this.whitespace = whitespace ?? false;
     this.host = host;
     this.url = url;
     this.id = id;
@@ -51,7 +53,7 @@ export class Input<M extends object = object> extends Ipt<M> {
   public override segment: Segment;
   public header: boolean;
   public local: boolean;
-  public sequential: boolean;
+  public whitespace: boolean;
   public recursion = new RecursionCounter(2);
   public readonly host?: URL;
   public readonly url?: URL;
@@ -115,10 +117,10 @@ export const enum State {
 }
 
 export const enum Recursion {
-  scope,
+  document,
   block,
   inline,
-  terminal,
+  bracket,
 }
 
 export const enum Backtrack {
@@ -134,12 +136,7 @@ export const enum Backtrack {
 }
 
 export const enum Command {
-  Error = '\x07',
   Cancel = '\x18',
   Escape = '\x1B',
   Separator = '\x1F',
 }
-
-export const CmdRegExp = {
-  Error: /\x07/g,
-} as const;

package/src/parser/document.ts

@@ -29,7 +29,7 @@ export const document: MarkdownParser = (() => {
       output.push();
       return output.context;
     },
-    recursion(Recursion.scope, force(() => loop)),
+    recursion(Recursion.document, force(() => loop)),
     (input, output) => {
       assert(input.position === input.source.length);
       const doc = frag(unwrap(output.pop()));

package/src/parser/inline/autolink/url.ts

@@ -39,12 +39,12 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
   ])));
 
 const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => backtrack(union([
-  surround(str('('), recursion(Recursion.terminal, some(union([bracket, unescsource]), ')')), str(')'),
+  surround(str('('), recursion(Recursion.bracket, some(union([bracket, unescsource]), ')')), str(')'),
     true, [3 | Backtrack.unescapable]),
-  surround(str('['), recursion(Recursion.terminal, some(union([bracket, unescsource]), ']')), str(']'),
+  surround(str('['), recursion(Recursion.bracket, some(union([bracket, unescsource]), ']')), str(']'),
     true, [3 | Backtrack.unescapable]),
-  surround(str('{'), recursion(Recursion.terminal, some(union([bracket, unescsource]), '}')), str('}'),
+  surround(str('{'), recursion(Recursion.bracket, some(union([bracket, unescsource]), '}')), str('}'),
     true, [3 | Backtrack.unescapable]),
-  surround(str('"'), precedence(2, recursion(Recursion.terminal, some(unescsource, '"'))), str('"'),
+  surround(str('"'), precedence(2, recursion(Recursion.bracket, some(unescsource, '"'))), str('"'),
     true, [3 | Backtrack.unescapable]),
 ])));

package/src/parser/inline/math.ts

@@ -41,7 +41,7 @@ export const math: MathParser = lazy(() => rewrite(
 
 const bracket: MathParser.BracketParser = lazy(() => backtrack(surround(
   str('{'),
-  recursion(Recursion.terminal,
+  recursion(Recursion.bracket,
   some(union([
     bracket,
     some(escsource, /[{}$\r\n]|(?<=[0-9A-Za-z]):\/\/[[0-9A-Za-z]/y),

package/src/parser/inline/media.ts

@@ -107,13 +107,13 @@ export const media: MediaParser = lazy(() => constraint(State.media, backtrack(o
   })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => union([
-  surround(str('('), recursion(Recursion.terminal, some(union([unsafehtmlentity, bracket, txt]), ')')), str(')'),
+  surround(str('('), recursion(Recursion.bracket, some(union([unsafehtmlentity, bracket, txt]), ')')), str(')'),
     true, [], undefined, () => Result.succ),
-  surround(str('['), recursion(Recursion.terminal, some(union([unsafehtmlentity, bracket, txt]), ']')), str(']'),
+  surround(str('['), recursion(Recursion.bracket, some(union([unsafehtmlentity, bracket, txt]), ']')), str(']'),
     true, [], undefined, () => Result.succ),
-  surround(str('{'), recursion(Recursion.terminal, some(union([unsafehtmlentity, bracket, txt]), '}')), str('}'),
+  surround(str('{'), recursion(Recursion.bracket, some(union([unsafehtmlentity, bracket, txt]), '}')), str('}'),
     true, [], undefined, () => Result.succ),
-  surround(str('"'), precedence(2, recursion(Recursion.terminal, some(union([unsafehtmlentity, txt]), '"'))), str('"'),
+  surround(str('"'), precedence(2, recursion(Recursion.bracket, some(union([unsafehtmlentity, txt]), '"'))), str('"'),
     true, [], undefined, () => Result.succ),
 ]));
 

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());
   }
 }