securemark 0.299.4 → 0.300.0

package/src/combinator/process/block.test.ts

@@ -0,0 +1,20 @@
+import { block } from './block';
+import { input } from '../parser';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/combinator/block', () => {
+  describe('block', () => {
+    it('invalid', () => {
+      assert.throws(() => inspect(block(() => []), (input(' \n'))));
+    });
+
+    it('valid', () => {
+      assert.deepStrictEqual(inspect(block(input => { input.position = input.source.length; return []; }), input('\n')), [[], '']);
+      assert.deepStrictEqual(inspect(block(input => { input.position = input.source.length; return []; }), input(' \n')), [[], '']);
+      assert.deepStrictEqual(inspect(block(input => { input.position = input.source.length; return []; }), input('\n\n')), [[], '']);
+      assert.deepStrictEqual(inspect(block(input => { input.position = input.source.length - 1; return []; }), input('\n\n')), [[], '\n']);
+    });
+
+  });
+
+});

package/src/combinator/process/block.ts

@@ -0,0 +1,33 @@
+import { Parser, Result, Segment } from '../parser';
+import { always } from '../control/state';
+import { backtrack } from '../effect/backtrack';
+import { isEmptyline } from './line';
+
+export function block<P extends Parser>(parser: P, separation?: boolean, segment?: number): P;
+export function block<T>(parser: Parser<T>, separation = true, segment = 0): Parser<T> {
+  assert(parser);
+  const cont: Result<T> = [
+    parser,
+    (input, output) => {
+      const { source, position } = input;
+      if (!output.state || separation && !isEmptyline(source, position)) return;
+      assert(position === source.length || source[position - 1] === '\n');
+      if (segment !== 0 && ~input.segment & Segment.write) {
+        input.segment = segment;
+      }
+      return output.context;
+    },
+  ];
+  return backtrack(always([
+    (input, output) => {
+      const { source, position } = input;
+      if (position === source.length) return;
+      if (segment !== 0 && input.segment & Segment.write) {
+        if (input.segment !== (segment | Segment.write)) return;
+        input.position = source.length;
+        return output.context;
+      }
+      return cont;
+    },
+  ]));
+}

package/src/combinator/process/clear.ts

@@ -0,0 +1,16 @@
+import { Parser, SubParsers, Input } from '../parser';
+import { always } from '../control/state';
+
+export function clear<S extends SubParsers<unknown>, I extends Input>(parser: Parser<unknown, I, S>): Parser<never, I, S> {
+  return always([
+    (_, output) => {
+      output.push();
+      return output.context;
+    },
+    parser,
+    (_, output) => {
+      output.pop();
+      return output.context;
+    },
+  ]);
+}

package/src/combinator/process/contract.ts

@@ -0,0 +1,35 @@
+import { Parser, Result, Input, Output } from '../parser';
+import { always } from '../control/state';
+import { tester } from '../delimiter';
+
+export function contract<P extends Parser>(patterns: string | RegExp, parser: P, cond: (input: Parser.Input<P>, output: Output<Parser.Node<P>>) => boolean): P;
+export function contract<P extends Parser>(precond: (input: Parser.Input<P>, output: Output<Parser.Node<P>>) => boolean, parser: P, postcond: (input: Parser.Input<P>, output: Output<Parser.Node<P>>) => boolean): P;
+export function contract<T>(precond: string | RegExp | ((input: Input, output: Output<T>) => boolean), parser: Parser<T>, postcond: (input: Input, output: Output<T>) => boolean): Parser<T> {
+  if (typeof precond !== 'function') {
+    precond = tester(precond, false);
+  }
+  return validate(precond, verify(parser, postcond));
+}
+
+export function validate<P extends Parser>(pattern: string | RegExp, parser: P): P;
+export function validate<P extends Parser>(cond: (input: Parser.Input<P>, output: Output<Parser.Node<P>>) => boolean, parser: P): P;
+export function validate<T>(cond: string | RegExp | ((input: Input, output: Output<T>) => boolean), parser: Parser<T>): Parser<T> {
+  if (typeof cond !== 'function') {
+    cond = tester(cond, false);
+  }
+  return always([
+    (input, output) =>
+      output.state && cond(input, output) ? output.context : Result.skip,
+    parser,
+  ]);
+}
+
+export function verify<P extends Parser>(parser: P, cond: (input: Parser.Input<P>, output: Output<Parser.Node<P>>) => boolean): P;
+export function verify<T>(parser: Parser<T>, cond: (input: Input, output: Output<T>) => boolean): Parser<T> {
+  assert(parser);
+  return always([
+    parser,
+    (input, output) =>
+      output.state && cond(input, output) ? output.context : Result.fail,
+  ]);
+}

package/src/combinator/process/duplicate.ts

@@ -0,0 +1,7 @@
+import { Parser, SubParsers, Input, List, Node } from '../parser';
+import { fmap } from './fmap';
+
+export function dup<T, I extends Input, S extends SubParsers<T, I>>(parser: Parser<T, I, S>): Parser<List<Node<T>>, I, S>;
+export function dup<T>(parser: Parser<T>): Parser<List<Node<T>>> {
+  return fmap(parser, nodes => new List([new Node(nodes)]));
+}

package/src/combinator/process/error.ts

@@ -0,0 +1,13 @@
+import { Parser } from '../parser';
+import { always } from '../control/state';
+
+export function error<P extends Parser>(parser: P): P;
+export function error<T>(parser: Parser<T>): Parser<T> {
+  assert(parser);
+  return always([
+    (input, output) => {
+      if (!output.error) return output.context;
+      return parser(input, output);
+    },
+  ]);
+}

package/src/combinator/{control/manipulation → process}/fallback.ts

@@ -1,7 +1,7 @@
-import { Parser } from '../../data/parser';
-import { union } from '../../data/parser/union';
+import { Parser, SubParsers } from '../parser';
+import { union } from '../control/union';
 
-export function fallback<P extends Parser>(parser: P, otherwise: Parser<Parser.Node<P>, Parser.Context<P>>): P;
+export function fallback<P extends Parser>(parser: P, otherwise: Parser<Parser.Node<P>, Parser.Input<P>, SubParsers<Parser.SubNode<P>, Parser.Input<P>>>): P;
 export function fallback<N>(parser: Parser<N>, otherwise: Parser<N>): Parser<N> {
   return union([parser, otherwise]);
 }

package/src/combinator/process/fence.ts

@@ -0,0 +1,59 @@
+import { Parser, SubParsers, Input, List, Node } from '../parser';
+import { spend } from '../effect/clock';
+import { firstline, isEmptyline } from './line';
+
+export function fence<I extends Input, S extends SubParsers<never, I>>(opener: RegExp, write: boolean, limit: number, separation = true): Parser<string, I, S> {
+  assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
+  return (input, output) => {
+    const { source, position } = input;
+    if (position === source.length) return;
+    opener.lastIndex = position;
+    const matches = opener.exec(source);
+    if (!matches) return;
+    assert(matches[0] === firstline(source, position));
+    spend(input, output, matches[0].length);
+    const delim = matches[1];
+    assert(delim && delim === delim.trim());
+    if (matches[0].includes(delim, delim.length)) return;
+    input.position += matches[0].length;
+    // Prevent annoying parsing in editing.
+    const secondline = firstline(source, input.position);
+    if (isEmptyline(secondline, 0) &&
+        firstline(source, input.position + secondline.length).trimEnd() !== delim) {
+      input.position -= matches[0].length;
+      return;
+    }
+    let body = '';
+    let closer = '';
+    let overflow = '';
+    for (let count = 1; ; ++count) {
+      if (input.position === source.length) break;
+      const line = firstline(source, input.position);
+      if ((closer || count > limit + 1) && isEmptyline(line, 0)) break;
+      if(closer) {
+        overflow += line;
+      }
+      if (!closer && count <= limit + 1 && line.startsWith(delim) && line.trimEnd() === delim) {
+        closer = line;
+        if (isEmptyline(source, input.position + line.length)) {
+          input.position += line.length;
+          break;
+        }
+        if (!separation) {
+          input.position += line.length;
+          break;
+        }
+        assert(!overflow);
+        overflow = line;
+      }
+      if (!overflow) {
+        body += line;
+      }
+      input.position += line.length;
+    }
+    write && output.push(
+      new List([body, overflow, closer].map(str => new Node(str)))
+        .import(new List(matches.map(str => new Node(str)))));
+    return output.context;
+  };
+}

package/src/combinator/process/fmap.ts

@@ -0,0 +1,10 @@
+import { Parser, Input, Output, List, Node } from '../parser';
+import { bind } from './bind';
+
+export function fmap<P extends Parser>(parser: Parser.IntermediateParser<P>, f: (nodes: List<Node<Parser.SubNode<P>>>, input: Parser.Input<P>, output: Output<Parser.Node<P>>) => List<Node<Parser.Node<P>>>): P;
+export function fmap<P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, input: Parser.Input<P>, output: Output<Parser.Node<P>>) => List<Node<Parser.Node<P>>>): P;
+export function fmap<T, P extends Parser>(parser: Parser<T, Parser.Input<P>, Parser.SubParsers<P>>, f: (nodes: List<Node<T>>, input: Parser.Input<P>, output: Output<Parser.Node<P>>) => List<Node<Parser.Node<P>>>): P;
+export function fmap<U, P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, input: Parser.Input<P>, output: Output<Parser.Node<P>>) => List<Node<U>>): Parser<U, Parser.Input<P>, Parser.SubParsers<P>>;
+export function fmap<T>(parser: Parser<T>, f: (nodes: List<Node<T>>, input: Input, output: Output<T>) => List<Node<T>>): Parser<T> {
+  return bind(parser, (nodes, input, output) => f(nodes, input, output));
+}

package/src/combinator/process/indent.test.ts

@@ -0,0 +1,31 @@
+import { indent } from './indent';
+import { Node, input } from '../parser';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/combinator/indent', () => {
+  describe('indent', () => {
+    it('valid', () => {
+      const parser = indent((input, output) => output.append(new Node(input.source)) && output.context);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' ')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('  ')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a ')), undefined);
+      assert.deepStrictEqual(inspect(parser, input(' a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a ')), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a \n')), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser, input('  a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('   a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('    a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('     a')), [[' a'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n a')), [['a\na'], '']);
+      assert.deepStrictEqual(inspect(parser, input(' a\n  a')), [['a\n a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('    a\n        a')), [['a\n    a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('  a\n a')), [['a'], ' a']);
+      assert.deepStrictEqual(inspect(parser, input(' \ta')), [['\ta'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\ta')), [['a'], '']);
+    });
+
+  });
+
+});

package/src/combinator/process/indent.ts

@@ -0,0 +1,51 @@
+import { Parser, Result, Node } from '../parser';
+import { some } from '../control/some';
+import { always } from '../control/state';
+import { block } from './block';
+import { line } from './line';
+import { match } from './match';
+import { open } from './surround';
+import { memoize } from 'spica/memoize';
+
+export function indent<P extends Parser>(parser: P, separation?: boolean): P;
+export function indent<P extends Parser>(opener: RegExp, parser: P, separation?: boolean): P;
+export function indent(opener: RegExp | Parser<string>, parser: Parser<string> | boolean = false, separation = false): Parser<string> {
+  if (typeof opener === 'function') {
+    separation = parser as boolean;
+    parser = opener;
+    opener = / {1,4}|\t{1,2}/y;
+  }
+  assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
+  assert(parser = parser as Parser<string>);
+  return always([
+    (input, output) => {
+      if (input.position === input.source.length) return Result.skip;
+      output.push();
+      return output.context;
+    },
+    block(match(opener, memoize(
+      ([indent]) =>
+        some(open(indent, line(({ source }, output) =>
+          output.append(new Node(source))))),
+      ([indent]) => indent.length * 2 + -(indent[0] === ' '), [], 2 ** 4 - 1)),
+      separation),
+    (input, output) => {
+      const source = trimBlockEnd(output.pop().foldl((acc, node) => acc + node.value, ''));
+      if (source === '') return Result.skip;
+      input.scope.focus(source);
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      input.scope.unfocus();
+      return output.context;
+    },
+  ]);
+}
+
+function trimBlockEnd(block: string): string {
+  return block === ''
+      || block.at(-1) !== '\n'
+    ? block
+    : block.slice(0, block.at(-2) === '\r' ? -2 : -1);
+}

package/src/combinator/process/lazy.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../parser';
+
+export function lazy<P extends Parser>(builder: () => P): P;
+export function lazy<T>(builder: () => Parser<T>): Parser<T> {
+  let parser: Parser<T> = (input, output) =>
+    (parser = builder())(input, output);
+  return (input, output) => parser(input, output);
+}

package/src/combinator/process/line.test.ts

@@ -0,0 +1,21 @@
+import { input } from '../parser';
+import { line } from './line';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/combinator/line', () => {
+  describe('line', () => {
+    it('invalid', () => {
+      assert.deepStrictEqual(inspect(line(() => []), input('')), undefined);
+    });
+
+    it('valid', () => {
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input(' ')), [[], '']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input('\n')), [[], '']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input('\n\n')), [[], '\n']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input(' \n')), [[], '']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length - 1; return []; }), input(' \n')), [[], '']);
+    });
+
+  });
+
+});

package/src/combinator/process/line.ts

@@ -0,0 +1,55 @@
+import { Parser, Result, Input } from '../parser';
+import { always } from '../control/state';
+
+export function line<P extends Parser>(parser: P, slice?: boolean): P;
+export function line<T>(parser: Parser<T>, slice: boolean = true): Parser<T> {
+  assert(parser);
+  interface Memory {
+    readonly position: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position } = input;
+      if (position === source.length) return Result.skip;
+      input.memory = {
+        position,
+      };
+      if (slice) {
+        const line = firstline(source, position);
+        input.position += line.length;
+        input.scope.focus(line);
+      }
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      if (slice) {
+        input.scope.unfocus(output.state, true);
+      }
+      if (!output.state) return;
+      const { source, position, memory } = input;
+      if (position === memory.position || position !== source.length && source[position - 1] !== '\n' && isEmptyline(source, position)) {
+        input.position = source.indexOf('\n', position) + 1 || source.length;
+      }
+      return output.state && (input.position === source.length || source[input.position - 1] === '\n')
+        ? output.context
+        : Result.fail;
+    },
+  ]);
+}
+
+export function firstline(source: string, position: number): string {
+  if (position === source.length) return '';
+  const i = source.indexOf('\n', position);
+  return i === -1
+    ? source.slice(position)
+    : source.slice(position, i + 1);
+}
+
+const emptyline = /[^\S\r\n]*(?:$|\r?\n)/y;
+export function isEmptyline(source: string, position: number): boolean {
+  emptyline.lastIndex = position;
+  return source.length === position
+      || source[position] === '\n'
+      || emptyline.test(source);
+}

package/src/combinator/process/match.ts

@@ -0,0 +1,37 @@
+import { Parser, Result, Input } from '../parser';
+import { always } from '../control/state';
+import { spend } from '../effect/clock';
+
+export function match<P extends Parser>(pattern: RegExp, f: (matched: RegExpMatchArray) => P): P;
+export function match<T>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<T>): Parser<T> {
+  assert(!pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^'));
+  interface Memory {
+    readonly position: number;
+    readonly range: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position } = input;
+      if (position === source.length) return Result.skip;
+      pattern.lastIndex = position;
+      const params = pattern.exec(source);
+      if (!params) return Result.skip;
+      assert(source.startsWith(params[0], position));
+      spend(input, output, params[0].length);
+      input.memory = {
+        position,
+        range: params[0].length,
+      };
+      return f(params)(input, output);
+    },
+    (input, output) => {
+      const { position, memory } = input;
+      input.position += output.state
+        ? position === memory.position
+          ? memory.range
+          : 0
+        : position - memory.position;
+      return output.context;
+    },
+  ]);
+}

package/src/combinator/process/reverse.ts

@@ -0,0 +1,7 @@
+import { Parser, List, Node } from '../parser';
+import { fmap } from './fmap';
+
+export function reverse<P extends Parser>(parser: P): P;
+export function reverse<T>(parser: Parser<T>): Parser<T> {
+  return fmap(parser, nodes => nodes.foldr((node, acc) => acc.push(nodes.delete(node)), new List<Node<T>>()));
+}

package/src/combinator/process/scope.ts

@@ -0,0 +1,102 @@
+import { Parser, Result, Input } from '../parser';
+import { matcher } from '../delimiter';
+import { always } from '../control/state';
+import { clear } from './clear';
+
+export function focus<P extends Parser>(scope: string | RegExp, parser: P, slice?: boolean): P;
+export function focus<T>(scope: string | RegExp, parser: Parser<T>, slice = true): Parser<T> {
+  assert(parser);
+  interface Memory {
+    readonly position: number;
+    readonly range: number;
+  }
+  const match = matcher(scope, slice);
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position } = input;
+      if (position === source.length) return Result.skip;
+      const src = match(input, output) ?? '';
+      assert(source.startsWith(src, position));
+      if (src === '') {
+        input.position = position;
+        return Result.skip;
+      }
+      input.range = src.length;
+      if (slice) {
+        input.scope.focus(src);
+      }
+      else {
+        input.memory = {
+          position,
+          range: input.range,
+        };
+      }
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      if (slice) {
+        input.scope.unfocus(output.state, true);
+      }
+      else {
+        input.position += output.state && input.position === input.memory.position
+          ? input.memory.range
+          : 0;
+      }
+      return output.context;
+    },
+  ]);
+}
+
+export function rewrite<P extends Parser>(scope: Parser<unknown, Parser.Input<P>>, parser: P, slice?: boolean): P;
+export function rewrite<T>(scope: Parser, parser: Parser<T>, slice = true): Parser<T> {
+  assert(scope);
+  assert(parser);
+  interface Memory {
+    readonly position: number;
+    range: number;
+    readonly linebreak: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position, linebreak } = input;
+      if (position === source.length) return Result.skip;
+      input.memory = {
+        position,
+        range: 0,
+        linebreak,
+      };
+      return output.context;
+    },
+    clear(scope),
+    (input, output) => {
+      const { source, position, memory } = input;
+      const range = position - memory.position;
+      input.range = memory.range = range;
+      input.linebreak = memory.linebreak;
+      if (!output.state || range === 0) {
+        input.position = memory.position;
+        return Result.skip;
+      }
+      if (slice) {
+        input.scope.focus(source.slice(position - range, position));
+      }
+      else {
+        input.position -= range;
+      }
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      if (slice) {
+        input.scope.unfocus(output.state, true);
+      }
+      else {
+        input.position += output.state && input.position === input.memory.position
+          ? input.memory.range
+          : 0;
+      }
+      return output.context;
+    },
+  ]);
+}