securemark 0.299.4 → 0.300.0

package/src/combinator/process/surround.ts

@@ -0,0 +1,271 @@
+import { Parser, Result, Input, Output, List, Node } from '../parser';
+import { tester } from '../delimiter';
+
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: Parser.IntermediateParser<P>,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: false,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>>, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: Parser.IntermediateParser<P>,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: false,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser<string>, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: false,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser<string>, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<T>(
+  opener: string | RegExp | Parser<T>,
+  parser: string | RegExp | Parser<T>,
+  closer: string | RegExp | Parser<T>,
+  optional: boolean = false,
+  backtracks: readonly number[] = [],
+  f?: (rss: [List<Node<T>>, List<Node<T>>, List<Node<T>>], input: Input, output: Output<T>) => Result<T>,
+  g?: (rss: [List<Node<T>>, List<Node<T>> | undefined], input: Input, output: Output<T>) => Result<T>,
+): Parser<T> {
+  switch (typeof opener) {
+    case 'string':
+    case 'object':
+      opener = wrap(opener);
+  }
+  assert(opener);
+  switch (typeof parser) {
+    case 'string':
+    case 'object':
+      parser = wrap(parser);
+  }
+  assert(parser);
+  switch (typeof closer) {
+    case 'string':
+    case 'object':
+      closer = wrap(closer);
+  }
+  assert(closer);
+  const [blen, rbs, wbs] = reduce(backtracks);
+  interface Memory {
+    readonly position: number;
+    readonly linebreak: number;
+    state: boolean;
+  }
+  const cont1: Result<T, Input<Memory>> = [
+    (input, output) => {
+      const { source, position, linebreak } = input;
+      if (position === source.length) return Result.skip;
+      input.linebreak = 0;
+      input.memory = {
+        position,
+        linebreak,
+        state: false,
+      };
+      output.push();
+      return cont2;
+    },
+    (input, output) => {
+      const { memory: { linebreak } } = input;
+      if (output.state) {
+        input.linebreak ||= linebreak;
+      }
+      else {
+        input.linebreak = linebreak;
+      }
+      return output.context;
+    },
+  ];
+  const cont2: Result<T, Input<Memory>> = [
+    opener,
+    (input, output) => {
+      const { memory: { position } } = input;
+      if (!output.state || rbs && isBacktrack(input, rbs, position, blen)) {
+        output.pop();
+        return;
+      }
+      output.push();
+      return cont3;
+    },
+  ];
+  const cont3: Result<T, Input<Memory>> = [
+    parser,
+    (input, output) => {
+      const { state } = output;
+      const { memory: { position } } = input;
+      input.range = input.position - position;
+      if (!output.state && !optional) {
+        wbs && setBacktrack(input, wbs, position);
+        const m = output.pop();
+        const o = output.pop();
+        if (!g) return;
+        output.state = true;
+        output.context = Result.succ;
+        return g([o, state ? m : undefined], input, output);
+      }
+      input.memory.state = output.state;
+      output.push();
+      return cont4;
+    },
+  ];
+  const cont4: Result<T, Input<Memory>> = [
+    closer,
+    (input, output) => {
+      const { memory: { position, state } } = input;
+      const c = output.pop();
+      const m = output.pop();
+      const o = output.pop();
+      input.range = input.position - position;
+      if (!output.state) {
+        wbs && setBacktrack(input, wbs, position);
+        if (!g) return;
+        output.state = true;
+        output.context = Result.succ;
+        return g([o, state ? m : undefined], input, output);
+      }
+      if (input.range === 0) return;
+      if (f) {
+        return f([o, state ? m : undefined as any, c], input, output);
+      }
+      else {
+        output.import(o.import(m).import(c));
+        return output.context;
+      }
+    },
+  ];
+  return () => cont1;
+}
+export function open<P extends Parser>(
+  opener: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  parser: P,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function open<P extends Parser<string>>(
+  opener: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  parser: string | RegExp | P,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function open<N>(
+  opener: string | RegExp | Parser<N, Input>,
+  parser: string | RegExp | Parser<N>,
+  optional?: boolean,
+  backtracks: readonly number[] = [],
+): Parser<N> {
+  return surround(opener, parser as Parser<N>, '', optional, backtracks);
+}
+export function close<P extends Parser>(
+  parser: P,
+  closer: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function close<P extends Parser<string>>(
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function close<N>(
+  parser: string | RegExp | Parser<N>,
+  closer: string | RegExp | Parser<N, Input>,
+  optional?: boolean,
+  backtracks: readonly number[] = [],
+): Parser<N> {
+  return surround('', parser as Parser<N>, closer, optional, backtracks);
+}
+
+const commandsize = 2;
+export function isBacktrack(
+  input: Input,
+  backtrack: number,
+  position: number = input.position,
+  length: number = 1,
+): boolean {
+  assert(1 & backtrack);
+  assert(backtrack >>> commandsize);
+  assert(0 < length && length < 3);
+  const { backtracks, offset } = input;
+  for (let i = 0; i < length; ++i) {
+    if (backtracks[position + i + offset] & backtrack >>> commandsize) return true;
+  }
+  return false;
+}
+export function setBacktrack(
+  input: Input,
+  backtrack: number,
+  position: number,
+  length: number = 1,
+): void {
+  // バックトラックの可能性がなく記録不要の場合もあるが判別が面倒なので省略
+  assert(2 & backtrack);
+  assert(backtrack >>> commandsize);
+  assert(0 < length && length < 3);
+  const { backtracks, offset } = input;
+  for (let i = 0; i < length; ++i) {
+    backtracks[position + i + offset] |= backtrack >>> commandsize;
+  }
+}
+
+function wrap<T>(pattern: string | RegExp): Parser<T> {
+  const test = tester(pattern, true);
+  return (input, output) => test(input, output) ? output.context : Result.fail;
+}
+
+function reduce(backtracks: readonly number[]): readonly [number, number, number] {
+  let len = 1;
+  let rbs = 0;
+  let wbs = 0;
+  for (const backtrack of backtracks) {
+    if (backtrack >>> commandsize === 0) {
+      len = backtrack;
+      assert(len > 0);
+      continue;
+    }
+    assert(backtrack >>> commandsize);
+    if (1 & backtrack) {
+      rbs |= backtrack;
+    }
+    if (2 & backtrack) {
+      wbs |= backtrack;
+    }
+  }
+  return [len, rbs, wbs];
+}

package/src/combinator.ts

@@ -1,24 +1,28 @@
-export * from './combinator/data/parser/union';
-export * from './combinator/data/parser/inits';
-export * from './combinator/data/parser/tails';
-export * from './combinator/data/parser/sequence';
-export * from './combinator/data/parser/subsequence';
-export * from './combinator/data/parser/some';
-export * from './combinator/data/parser/context';
-export * from './combinator/control/constraint/block';
-export * from './combinator/control/constraint/line';
-export * from './combinator/control/constraint/contract';
-export * from './combinator/control/manipulation/fence';
-export * from './combinator/control/manipulation/indent';
-export * from './combinator/control/manipulation/scope';
-export * from './combinator/control/manipulation/clear';
-export * from './combinator/control/manipulation/surround';
-export * from './combinator/control/manipulation/match';
-export * from './combinator/control/manipulation/convert';
-export * from './combinator/control/manipulation/duplicate';
-export * from './combinator/control/manipulation/reverse';
-export * from './combinator/control/manipulation/fallback';
-export * from './combinator/control/manipulation/recovery';
-export * from './combinator/control/manipulation/lazy';
-export * from './combinator/control/monad/fmap';
-export * from './combinator/control/monad/bind';
+export * from './combinator/control/union';
+export * from './combinator/control/inits';
+export * from './combinator/control/tails';
+export * from './combinator/control/sequence';
+export * from './combinator/control/subsequence';
+export * from './combinator/control/some';
+export * from './combinator/control/state';
+export * from './combinator/effect/state';
+export * from './combinator/effect/clock';
+export * from './combinator/effect/recursion';
+export * from './combinator/effect/precedence';
+export * from './combinator/effect/scope';
+export * from './combinator/effect/backtrack';
+export * from './combinator/process/block';
+export * from './combinator/process/line';
+export * from './combinator/process/contract';
+export * from './combinator/process/fence';
+export * from './combinator/process/indent';
+export * from './combinator/process/scope';
+export * from './combinator/process/clear';
+export * from './combinator/process/surround';
+export * from './combinator/process/match';
+export * from './combinator/process/duplicate';
+export * from './combinator/process/reverse';
+export * from './combinator/process/fallback';
+export * from './combinator/process/lazy';
+export * from './combinator/process/fmap';
+export * from './combinator/process/bind';

package/src/debug.test.ts

@@ -1,12 +1,15 @@
-import { Parser, Input } from './combinator/data/parser';
+import { Parser, Input, Output, run } from './combinator/parser';
 import { html, define } from 'typed-dom/dom';
 import { querySelectorWith, querySelectorAllWith } from 'typed-dom/query';
 
-export function inspect(parser: Parser<DocumentFragment | HTMLElement | string>, input: Input, until: number | string = Infinity): [string[], string] | undefined {
-  const context = input;
-  const result = parser(input);
-  return result && [
-    result.foldl<string[]>((acc, { value: node }) => {
+export function inspect(parser: Parser<DocumentFragment | HTMLElement | string>, input: Input, until: number | string = Infinity): [...string[][], string] | undefined {
+  const output = new Output<DocumentFragment | HTMLElement | string>();
+  for (const _ of run(parser, input, output));
+  assert.deepStrictEqual(output.data, [output.data[0]]);
+  assert(output.state || output.peek().length === 0);
+  assert(!output.error);
+  return !output.state ? undefined : [
+    ...output.data.map(nodes => nodes.foldl<string[]>((acc, { value: node }) => {
       assert(node);
       if (typeof node === 'string') return acc.push(node), acc;
       if (node instanceof DocumentFragment) return acc.push(html('div', [node]).innerHTML), acc;
@@ -35,8 +38,8 @@ export function inspect(parser: Parser<DocumentFragment | HTMLElement | string>,
         assert(el.innerHTML.startsWith(node.outerHTML.slice(0, until)));
       }
       return acc.push(normalize(node.outerHTML.slice(0, until))), acc;
-    }, []),
-    context.source.slice(context.position),
+    }, [])),
+    input.source.slice(input.position),
   ];
 }
 

package/src/parser/autolink.test.ts

@@ -1,6 +1,5 @@
 import { autolink } from './autolink';
-import { input } from '../combinator/data/parser';
-import { Context } from './context';
+import { input } from './context';
 import { inspect } from '../debug.test';
 
 describe('Unit: parser/autolink', () => {
@@ -8,22 +7,22 @@ describe('Unit: parser/autolink', () => {
     const parser = autolink;
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('http://host)', new Context())), [['<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('http://host\\', new Context())), [['<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('!http://host)', new Context())), [['!', '<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('!http://host\\', new Context())), [['!', '<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('#a', new Context())), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('@a#b', new Context())), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['\\', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a#b', new Context())), [['a', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0a#b', new Context())), [['0a', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('あ#b', new Context())), [['あ', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('あい#b', new Context())), [['あい', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0aあ#b', new Context())), [['0a', 'あ', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0aあい#b', new Context())), [['0a', 'あい', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a\n#b', new Context())), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a\\\n#b', new Context())), [['a', '\\', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0a>>b', new Context())), [['0a', '>', '>b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('http://host)')), [['<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('http://host\\')), [['<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host)')), [['!', '<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host\\')), [['!', '<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('#a')), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a#b')), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n')), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a#b')), [['a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0a#b')), [['0a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('あ#b')), [['あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('あい#b')), [['あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0aあ#b')), [['0a', 'あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0aあい#b')), [['0a', 'あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\n#b')), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\\\n#b')), [['a', '\\', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0a>>b')), [['0a', '>', '>b'], '']);
     });
 
   });