123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247
import type { IParser, Input, Result } from "./core.ts";
/** * Execute the embedded parser with a specified prefix and suffix. * * If the prefix parser or suffix parser fails, the whole parser will fail. * *     const parser = between(char("["), char("]"), digit()); *     parser("[5]").output === "5"; *     parser("(5]").ok === false; *     parser("[a]").ok === false; *     parser("[5)").ok === false; * * @param start Parser to parse the prefix. * @param end Parser to parse the suffix. * @param parser Embedded parser. */export function between<T, EL, ER, ET, I extends Input, CtxIn, CtxOut>(  start: IParser<unknown, EL, I, CtxIn, CtxOut>,  end: IParser<unknown, ER, I, CtxIn, CtxOut>,  parser: IParser<T, ET, I, CtxIn, CtxOut>,): IParser<T, EL | ER | ET, I, CtxIn, CtxOut> {  function parse<C extends CtxIn>(    input: I,    context: C = Object.create(null),  ): Result<I, T, EL | ER | ET, C & CtxOut> {    const left = parse.start(input, context);    if (!left.ok) {      return left;    }
    const mid = parse.parser(left.input, left.context);    if (!mid.ok) {      return mid;    }
    const right = parse.end(mid.input, mid.context);    if (!right.ok) {      return right;    }
    return {      ok: true,      input: right.input,      output: mid.output,      context: right.context,    };  }  parse.start = start;  parse.parser = parser;  parse.end = end;
  return parse;}
type UnionToIntersection<U> =  (U extends unknown ? (arg: U) => void : never) extends    ((arg: infer T) => void) ? T : never;
type SerialOutput<  I extends Input,  P extends readonly IParser<unknown, unknown, I, unknown, unknown>[],> = {  [K in keyof P]: P[K] extends IParser<infer O, infer _, I, infer _, infer _>    ? O    : never;};type SerialError<  I extends Input,  P extends readonly IParser<unknown, unknown, I, unknown, unknown>[],> = P[number] extends IParser<infer _, infer E, I, infer _, infer _> ? E  : never;type SerialCtxIn<  I extends Input,  P extends readonly IParser<unknown, unknown, I, unknown, unknown>[],> = UnionToIntersection<  P[number] extends IParser<infer _, infer _, I, infer C, infer _> ? C    : never>;type SerialCtxOut<  I extends Input,  P extends readonly IParser<unknown, unknown, I, unknown, unknown>[],> = UnionToIntersection<  P[number] extends IParser<infer _, infer _, I, infer _, infer C> ? C    : never>;type SerialParser<  I extends Input,  P extends readonly IParser<unknown, unknown, I>[],> = IParser<  SerialOutput<I, P>,  SerialError<I, P>,  I,  SerialCtxIn<I, P>,  SerialCtxOut<I, P>>;
/** * Execute a series of parsers and follow its order. * Once a parser fails, * the whole parser will fail and return last parsing error. * *     const parser = serial(char("<"), char("-"), char(">")); *     parser("<->").output; // ==> ["<", "-", ">"] *     parser(">-<").ok === false; *     parser("<-!").ok === false; *     parser("<_>").ok === false; * * @param parsers Series of parser. Order is sensitive. */export function serial<  P extends IParser<unknown, unknown, string, unknown, unknown>[],>(  ...parsers: P): SerialParser<string, P>;/** * Execute a series of parsers and follow its order. * Once a parser fails, * the whole parser will fail and return last parsing error. * *     const parser = serial(byte(13), byte(10), byte(65)); *     parser(Uint8Array.of(13, 10, 65)).output; // ==> Uint8Array [13, 10, 65] *     parser(Uint8Array.of(13, 65, 10)).ok === false; *     parser(Uint8Array.of(13, 10, 66)).ok === false; *     parser(Uint8Array.of(13, 11, 65)).ok === false; * * @param parsers Series of parser. Order is sensitive. */export function serial<  P extends IParser<unknown, unknown, Uint8Array, unknown, unknown>[],>(  ...parsers: P): SerialParser<Uint8Array, P>;export function serial<  I extends Input,  P extends IParser<unknown, unknown, I, unknown, unknown>[],>(...parsers: P): SerialParser<I, P> {  function parse<C extends SerialCtxIn<I, P>>(    input: I,    context: C = Object.create(null),  ): Result<I, SerialOutput<I, P>, SerialError<I, P>, C & SerialCtxOut<I, P>> {    const output: unknown[] = [];
    for (const parser of parse.parsers) {      const result = parser(input, context);      if (!result.ok) {        return result as {          ok: false;          input: I;          error: SerialError<I, P>;          context: C & SerialCtxOut<I, P>;        };      }
      input = result.input;      context = result.context;      output.push(result.output);    }
    return {      ok: true,      input,      output: output as SerialOutput<I, P>,      context: context as C & SerialCtxOut<I, P>,    };  }  parse.parsers = parsers;
  return parse;}
/** * Execute the "prefix" parse first. * If it succeeds, discard its result and execute the following normal parser. * * If any of both parsers fails, the whole parser will fail. * *     const parser = prefix(char("<"), digit()); *     parser("<5").output === "5"; *     parser("[5").ok === false; *     parser("<a").ok === false; * * @param prefix parser to parse prefix * @param parser parser to parse normal stuff */export function prefix<T, ET, EP, I extends Input, CtxIn, CtxOut>(  prefix: IParser<unknown, EP, I, CtxIn, CtxOut>,  parser: IParser<T, ET, I, CtxIn, CtxOut>,): IParser<T, ET | EP, I, CtxIn, CtxOut> {  function parse<C extends CtxIn>(    input: I,    context: C = Object.create(null),  ): Result<I, T, ET | EP, C & CtxOut> {    const preceded = parse.prefix(input, context);    if (!preceded.ok) {      return preceded;    }
    return parse.parser(preceded.input, preceded.context);  }  parse.parser = parser;  parse.prefix = prefix;
  return parse;}
/** * Execute the normal parser first. * If it succeeds, execute the following "suffix" parser * and discard the output of the "suffix" parser if succeeds. * * If any of both parsers fails, the whole parser will fail. * *     const parser = suffix(digit(), char(">")); *     parser("5>").output === "5"; *     parser("5]").ok === false; *     parser("a>").ok === false; * * @param parser parser to parse normal stuff * @param suffix parser to parse suffix */export function suffix<T, ET, ES, I extends Input, CtxIn, CtxOut>(  parser: IParser<T, ET, I, CtxIn, CtxOut>,  suffix: IParser<unknown, ES, I, CtxIn, CtxOut>,): IParser<T, ET | ES, I, CtxIn, CtxOut> {  function parse<C extends CtxIn>(    input: I,    context: C = Object.create(null),  ): Result<I, T, ET | ES, C & CtxOut> {    const result = parser(input, context);    if (!result.ok) {      return result;    }
    const terminated = suffix(result.input, result.context);    if (terminated.ok) {      return { ...terminated, output: result.output };    } else {      return terminated;    }  }  parse.parser = parser;  parse.suffix = suffix;
  return parse;}