securemark 0.299.3 → 0.300.0

package/src/parser/inline.ts

@@ -50,76 +50,110 @@ export import AutolinkParser = InlineParser.AutolinkParser;
 
 const stars = strs('*');
 
+const p1 = lazy(() => union([
+  annotation,
+  bracket,
+]));
+const p2 = lazy(() => union([
+  reference,
+  textlink,
+  bracket,
+]));
+const p3 = lazy(() => union([
+  remark,
+  textlink,
+  ruby,
+  bracket,
+]));
+const p4 = lazy(() => union([
+  extension,
+  textlink,
+  ruby,
+  bracket,
+]));
+const p5 = lazy(() => union([
+  textlink,
+  ruby,
+  bracket,
+]));
+const p6 = lazy(() => union([
+  template,
+  bracket,
+]));
+const p7 = lazy(() => union([
+  textlink,
+  bracket,
+]));
+const p8 = lazy(() => union([
+  label,
+  math,
+]));
+const p9 = lazy(() => union([
+  emstrong,
+  stars,
+]));
+const p10 = lazy(() => union([
+  strong,
+  stars,
+]));
 export const inline: InlineParser = lazy(() => union([
-  input => {
+  (input, output) => {
     const { source, position } = input;
     if (position === source.length) return;
     switch (source[position]) {
       case '(':
-        if (source[position + 1] === '(') return annotation(input) || bracket(input);
-        return bracket(input);
+        if (source[position + 1] === '(') return p1(input, output);
+        return bracket(input, output);
       case '[':
         switch (source[position + 1]) {
           case '[':
-            return reference(input)
-                || textlink(input)
-                || bracket(input);
+            return p2(input, output);
           case '%':
-            return remark(input)
-                || textlink(input)
-                || ruby(input)
-                || bracket(input);
+            return p3(input, output);
           case '#':
           case '$':
           case ':':
           case '^':
           case '|':
-            return extension(input)
-                || textlink(input)
-                || ruby(input)
-                || bracket(input);
+            return p4(input, output);
         }
-        return textlink(input)
-            || ruby(input)
-            || bracket(input);
+        return p5(input, output);
       case '{':
-        if (source[position + 1] === '{') return template(input) || bracket(input);
-        return textlink(input)
-            || bracket(input);
+        if (source[position + 1] === '{') return p6(input, output);
+        return p7(input, output);
       case '"':
       case '（':
       case '［':
       case '｛':
-        return bracket(input);
+        return bracket(input, output);
       case '<':
-        if (isAlphabet(source[position + 1])) return html(input);
+        if (isAlphabet(source[position + 1])) return html(input, output);
         break;
       case '$':
-        if (source[position + 1] === '{') return math(input);
-        return label(input)
-            || math(input);
+        if (source[position + 1] === '{') return math(input, output);
+        return p8(input, output);
       case '+':
-        if (source[position + 1] === '+') return insertion(input);
+        if (source[position + 1] === '+') return insertion(input, output);
         break;
       case '~':
-        if (source[position + 1] === '~') return deletion(input);
+        if (source[position + 1] === '~') return deletion(input, output);
         break;
       case '=':
-        if (source[position + 1] === '=') return mark(input);
+        if (source[position + 1] === '=') return mark(input, output);
         break;
       case '/':
-        if (source[position + 1] === '/' && source[position + 2] === '/') return italic(input);
+        if (source[position + 1] === '/' && source[position + 2] === '/') return italic(input, output);
         break;
       case '*':
         return source[position + 1] === '*'
           ? source[position + 2] === '*'
-            ? emstrong(input) || stars(input)
-            : strong(input) || stars(input)
-          : emphasis(input);
+            ? p9(input, output)
+            : p10(input, output)
+          : emphasis(input, output);
       case '`':
-        return code(input);
+        return code(input, output);
       case '&':
-        return htmlentity(input);
+        return htmlentity(input, output);
     }
   },
   autolink,

package/src/parser/node.ts

@@ -1,4 +1,4 @@
-import { invisibleBlankHTMLEntityNames } from './api/normalize';
+import { invisibleBlankHTMLEntityNames } from '../api/normalize';
 
 export const enum Flag {
   none,

package/src/parser/parser.ts

@@ -0,0 +1,51 @@
+import { Input, Segment } from './context';
+import { Parser, Result, List, Node } from '../combinator/parser';
+
+export function build(segment: Parser<string, Input>, block: Parser<HTMLElement, Input>): Result<HTMLElement> {
+  interface Memory {
+    readonly position: number;
+  }
+  const loop: Result<string | HTMLElement, Input<Memory | List<Node<string>>>> = [
+    (input, output) => {
+      input.segment = Segment.unknown;
+      input.memory = {
+        position: input.position,
+      };
+      output.push();
+      return output.context;
+    },
+    segment,
+    (input, output) => {
+      input.segment |= Segment.write;
+      const segs = output.pop() as List<Node<string>>;
+      assert(input.memory = input.memory as Memory);
+      if (segs.length === 0) {
+        segs.push(new Node(input.source.slice(input.memory.position, input.position)));
+      }
+      input.memory = segs;
+      return input.memory.length === 0
+        ? output.context
+        : subloop;
+    },
+    (input, output) => {
+      input.header &&= false;
+      return input.position === input.source.length
+        ? output.context
+        : loop;
+    },
+  ];
+  const subloop: Result<HTMLElement, Input<List<Node<string>>>> = [
+    (input, output) => {
+      input.scope.focus(input.memory.shift()!.value);
+      return output.context;
+    },
+    block,
+    (input, output) => {
+      input.scope.unfocus();
+      return input.memory.length === 0
+        ? output.context
+        : subloop;
+    },
+  ];
+  return loop;
+}

package/src/parser/repeat.ts

@@ -1,117 +1,144 @@
-import { Parser, Result, List, Node } from '../combinator/data/parser';
-import { tester } from '../combinator/data/delimiter';
+import { Parser, Result, Output, List, Node } from '../combinator/parser';
+import { tester } from '../combinator/delimiter';
 import { recur } from '../combinator';
-import { Context, Recursion, Command } from './context';
+import { Input, Recursion, Command } from './context';
 import { min } from 'spica/alias';
 
-export function repeat<P extends Parser<HTMLElement | string, Context>>(
+export function repeat<P extends Parser<HTMLElement | string, Input>>(
   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) =>
+  cons: (nodes: List<Node<Parser.Node<P>>>, input: Parser.Input<P>, output: Output<Parser.Node<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) =>
+  termination?: (nodes: List<Node<Parser.Node<P>>>, input: Input, output: Output<Parser.Node<P>>, 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, 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) =>
-    Result<string | N, Context> =
-    (nodes, context, prefix, postfix) => {
-      const acc = new List<Node<string | N>>();
+export function repeat<T extends HTMLElement | string>(
+  opener: string, after: string | RegExp, closer: string, recursion: Recursion, parser: Parser<string | T>,
+  cons: (nodes: List<Node<string | T>>, input: Input, output: Output<string | T>, lead: number, follow: number) =>
+    List<Node<T>>,
+  termination: (nodes: List<Node<string | T>>, input: Input, output: Output<string | T>, prefix: number, postfix: number, state: boolean) =>
+    Result<string | T, Input> =
+    (nodes, input, output, prefix, postfix) => {
       if (prefix > 0) {
-        acc.push(new Node(opener[0].repeat(prefix)));
-        context.range += prefix;
+        nodes.unshift(new Node(opener[0].repeat(prefix)));
+        input.range += prefix;
       }
-      acc.import(nodes);
       if (postfix > 0) {
-        const { source, position } = context;
-        acc.push(new Node(source.slice(position, position + postfix)));
-        context.position += postfix;
-        context.range += postfix;
+        const { source, position } = input;
+        nodes.push(new Node(source.slice(position, position + postfix)));
+        input.position += postfix;
+        input.range += postfix;
       }
-      return acc;
+      return output.import(nodes);
     },
-): Parser<string | N, Context> {
+): Parser<string | T, Input> {
   const test = tester(after, false);
-  return input => {
-    const context = input;
-    const { source, position, resources: { recursions } } = context;
-    if (!source.startsWith(opener, context.position)) return;
-    let nodes = new List<Node<N>>();
-    let i = opener.length;
-    for (; source[context.position + i] === source[context.position];) ++i;
-    context.position += i;
-    if (test(input) === undefined) {
-      context.position = position;
-      return;
-    }
-    let depth = i / opener.length + 1 | 0;
-    recur(recursions, recursion, depth, true);
-    let state = false;
-    let follow = 0;
-    for (; i >= opener.length; i -= opener.length, follow -= closer.length) {
-      recur(recursions, recursion, -1);
-      depth -= 1;
-      const lead = i - opener.length;
-      if (source.startsWith(closer, context.position)) {
-        context.position += closer.length;
-        const pos = context.position;
-        follow = follow > 0 ? follow : countFollows(source, pos, closer, lead / opener.length | 0);
-        nodes = cons(nodes, context, lead, follow);
-        if (context.position > pos) {
-          const advance = context.position - pos;
-          i -= advance;
-          follow -= advance;
-          depth -= advance / closer.length | 0;
+  interface Memory {
+    readonly position: number;
+    i: number;
+    lead: number;
+    follow: number;
+    state: boolean;
+    depth: number;
+  }
+  const cont: Result<T, Input<Memory>> = [
+    (input, output) => {
+      const { source, position, resources: { recursions } } = input;
+      if (!source.startsWith(opener, input.position)) return Result.skip;
+      let i = opener.length;
+      for (; source[input.position + i] === source[input.position];) ++i;
+      input.position += i;
+      if (!test(input, output)) {
+        input.position = position;
+        return Result.skip;
+      }
+      let depth = i / opener.length + 1 | 0;
+      recur(output, recursions, recursion, depth, true);
+      input.memory = {
+        position,
+        i,
+        lead: 0,
+        follow: 0,
+        state: false,
+        depth,
+      };
+      output.push();
+      return loop;
+    },
+    (input, output) => {
+      const { source, memory: m, resources: { recursions } } = input;
+      recur(output, recursions, recursion, -m.depth);
+      m.depth = 0;
+      const prefix = m.i;
+      m.i = 0;
+      for (let len = min(prefix, source.length - input.position); m.i < len && source[input.position + m.i] === closer[0];) {
+        ++m.i;
+      }
+      const postfix = m.i;
+      input.range = input.position - m.position - prefix;
+      return termination(output.pop(), input, output, prefix, postfix, m.state);
+    },
+  ];
+  const loop: Result<T, Input<Memory>> = [
+    (input, output) => {
+      const { source, memory: m, resources: { recursions } } = input;
+      for (; m.i >= opener.length; m.i -= opener.length, m.follow -= closer.length) {
+        recur(output, recursions, recursion, -1);
+        m.depth -= 1;
+        const lead = m.lead = m.i - opener.length;
+        if (source.startsWith(closer, input.position)) {
+          input.position += closer.length;
+          const pos = input.position;
+          m.follow = m.follow > 0 ? m.follow : countFollows(source, pos, closer, lead / opener.length | 0);
+          output.push(cons(output.pop(), input, output, lead, m.follow));
+          if (input.position > pos) {
+            const advance = input.position - pos;
+            m.i -= advance;
+            m.follow -= advance;
+            m.depth -= advance / closer.length | 0;
+          }
+          continue;
         }
-        continue;
+        return output.context;
       }
-      const buf = context.buffer;
-      context.buffer = nodes;
-      const result = parser(input);
-      context.buffer = buf;
-      context.range = context.position - position - i + opener.length;
-      if (result === undefined) break;
-      const pos = context.position;
-      nodes = result;
+      return Result.skip;
+    },
+    parser,
+    (input, output) => {
+      const { source, memory: m } = input;
+      const { lead } = m;
+      input.range = input.position - m.position - m.i + opener.length;
+      if (!output.state) return;
+      const pos = input.position;
+      const nodes = output.peek();
       switch (nodes.last?.value) {
         case Command.Cancel:
-          assert(!source.startsWith(closer, context.position));
+          assert(!source.startsWith(closer, input.position));
           nodes.pop();
-          state = false;
-          break;
+          m.state = false;
+          return;
         case Command.Separator:
-          assert(!source.startsWith(closer, context.position));
-          follow = follow > 0 ? follow : countFollows(source, pos, closer, lead / opener.length | 0);
+          assert(!source.startsWith(closer, input.position));
+          m.follow = m.follow > 0 ? m.follow : countFollows(source, pos, closer, lead / opener.length | 0);
           nodes.pop();
-          state = true;
-          continue;
+          m.state = true;
+          m.i -= opener.length, m.follow -= closer.length;
+          return loop;
         default:
-          follow = follow > 0 ? follow : countFollows(source, pos, closer, lead / opener.length | 0);
-          nodes = cons(nodes, context, lead, follow);
-          state = true;
-          if (context.position > pos) {
-            const advance = context.position - pos;
-            i -= advance;
-            follow -= advance;
-            depth -= advance / closer.length | 0;
+          m.follow = m.follow > 0 ? m.follow : countFollows(source, pos, closer, lead / opener.length | 0);
+          output.push(cons(output.pop(), input, output, lead, m.follow));
+          m.state = true;
+          if (input.position > pos) {
+            const advance = input.position - pos;
+            m.i -= advance;
+            m.follow -= advance;
+            m.depth -= advance / closer.length | 0;
           }
-          continue;
+          m.i -= opener.length, m.follow -= closer.length;
+          return loop;
       }
-      break;
-    }
-    recur(recursions, recursion, -depth);
-    depth = 0;
-    const prefix = i;
-    i = 0;
-    for (let len = min(prefix, source.length - context.position); i < len && source[context.position + i] === closer[0];) {
-      ++i;
-    }
-    const postfix = i;
-    context.range = context.position - position - prefix;
-    return termination(nodes, context, prefix, postfix, state);
-  };
+    },
+  ];
+  return () => cont;
 }
 
 function countFollows(source: string, position: number, closer: string, limit: number): number {

package/src/parser/segment.test.ts

@@ -1,18 +1,7 @@
 import { segment } from './segment';
-import { Command } from './context';
 
 describe('Unit: parser/segment', () => {
   describe('segment', () => {
-    it('huge input', () => {
-      const result = segment(`${'\n'.repeat(1e6 + 1)}`).next().value?.[0].split('\n', 1)[0];
-      assert(result?.startsWith(`${Command.Error}Too large input`));
-    });
-
-    it('huge segment', () => {
-      const result = segment(`${'\n'.repeat(1e5 + 1)}`).next().value?.[0].split('\n', 1)[0];
-      assert(result?.startsWith(`${Command.Error}Too large segment`));
-    });
-
     it('basic', () => {
       assert.deepStrictEqual([...segment('')].map(t => t[0]), []);
       assert.deepStrictEqual([...segment('a')].map(t => t[0]), ['a']);

package/src/parser/segment.ts

@@ -1,5 +1,6 @@
 import { MarkdownParser } from '../../markdown';
-import { MAX_INPUT_SIZE, MAX_SEGMENT_SIZE, Context, Segment, Command } from './context';
+import { Input, Segment } from './context';
+import { Output, List, Node, run } from '../combinator/parser';
 import { union, some } from '../combinator';
 import { segment as heading } from './block/heading';
 import { segment as codeblock } from './block/codeblock';
@@ -9,54 +10,50 @@ import { contentline, emptysegment } from './source';
 
 import SegmentParser = MarkdownParser.SegmentParser;
 
-const parser: SegmentParser = union([
-  some(emptysegment, MAX_SEGMENT_SIZE + 1),
-  input => {
+export const parser: SegmentParser = union([
+  some(emptysegment),
+  (input, output) => {
     const { source, position } = input;
     if (position === source.length) return;
     switch (source[position]) {
       case '`':
-        if (source.startsWith('```', position)) return codeblock(input);
+        if (source.startsWith('```', position)) return codeblock(input, output);
         break;
       case '~':
-        if (source.startsWith('~~~', position)) return extension(input);
+        if (source.startsWith('~~~', position)) return extension(input, output);
         break;
       case '$':
-        if (source[position + 1] === '$') return mathblock(input);
-        return extension(input);
+        if (source[position + 1] === '$') return mathblock(input, output);
+        return extension(input, output);
       case '[':
-        if (source[position + 1] === '$') return extension(input);
+        if (source[position + 1] === '$') return extension(input, output);
         break;
       case '#':
-        return heading(input);
+        return heading(input, output);
     }
   },
-  some(contentline, MAX_SEGMENT_SIZE + 1),
+  some(contentline),
 ]);
 
-export function* segment(source: string, initial = true): Generator<readonly [string, Segment], undefined, undefined> {
-  if (initial && !validate(source, MAX_INPUT_SIZE)) return yield [`${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`, Segment.unknown];
+export function* segment(source: string): Generator<readonly [string, Segment], undefined, undefined> {
   assert(source.length < Number.MAX_SAFE_INTEGER);
+  const input = new Input({ source, segment: Segment.unknown });
+  const output = new Output<string>();
   for (let position = 0, len = source.length; position < len;) {
-    const context = new Context({ source, position });
-    const result = parser(context)!;
-    assert(result);
-    assert(context.position > position);
+    input.segment = Segment.unknown;
+    for (const _ of run(parser, input, output));
+    assert(~input.segment & Segment.write);
+    assert(input.position > position);
+    assert(output.data.length === 1);
+    const result = new List<Node<string>>().import(output.peek());
     const segs = result.length === 0
-      ? [source.slice(position, context.position)]
+      ? [source.slice(position, input.position)]
       : result.foldl<string[]>((acc, { value }) => (acc.push(value), acc), []);
-    assert(segs.join('') === source.slice(position, context.position));
-    position = context.position;
+    assert(segs.join('') === source.slice(position, input.position));
+    position = input.position;
     for (let i = 0; i < segs.length; ++i) {
       const seg = segs[i];
-      initial && !validate(seg, MAX_SEGMENT_SIZE)
-        ? yield [`${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`, Segment.unknown]
-        : yield [seg, context.segment];
+      yield [seg, input.segment];
     }
   }
 }
-
-function validate(source: string, size: number): boolean {
-  return source.length <= size / 2
-      || source.length <= size && new Blob([source]).size <= size;
-}

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

@@ -1,7 +1,6 @@
 import { escsource } from './escapable';
 import { some } from '../../combinator';
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { input } from '../context';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/escsource', () => {
@@ -9,40 +8,40 @@ describe('Unit: parser/source/escsource', () => {
     const parser = some(escsource);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
     });
 
     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('09あいAZaz', new Context())), [['09あいAZaz'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab')), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a b c')), [['a b c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('09あいAZaz')), [['09あいAZaz'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser, input(' ', new Context())), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser, input('  ', new Context())), [['  '], '']);
-      assert.deepStrictEqual(inspect(parser, input('   ', new Context())), [['   '], '']);
-      assert.deepStrictEqual(inspect(parser, input(' \n', new Context())), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('  \n', new Context())), [['  ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('   \n', new Context())), [['   ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' ')), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser, input('  ')), [['  '], '']);
+      assert.deepStrictEqual(inspect(parser, input('   ')), [['   '], '']);
+      assert.deepStrictEqual(inspect(parser, input(' \n')), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  \n')), [['  ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('   \n')), [['   ', '<br>'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser, input('\n\n', new Context())), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\n\n')), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
-      assert.deepStrictEqual(inspect(parser, input('\\', new Context())), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\\', new Context())), [['\\\\'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\\\\', new Context())), [['\\\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\ ', new Context())), [['\\ '], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\_', new Context())), [['\\_'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\0', new Context())), [['\\0'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\a', new Context())), [['\\a'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\$', new Context())), [['\\$'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\　', new Context())), [['\\　'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\')), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\')), [['\\\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\\\\')), [['\\\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\ ')), [['\\ '], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\_')), [['\\_'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\0')), [['\\0'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\a')), [['\\a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\$')), [['\\$'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\　')), [['\\　'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n')), [['\\', '<br>'], '']);
     });
 
   });