Function parse

src/index.ts:35–130

(
  input: string,
  iterable: ParseGenerator<Result>
)

  | Iterable<ParseItem>;

export function parse<Result = void>(
  input: string,
  iterable: ParseGenerator<Result>
): ParseResult<Result> {
  let lastResult: ParseYieldedValue<ParseItem> | undefined;

  let iterationCount = -1;
  const iterator = iterable[Symbol.iterator]();

  main: while (true) {
    const nestedErrors: Array<ParseError> = [];

    iterationCount += 1;
    const next = iterator.next(lastResult as any);
    if (next.done) {
      if (next.value instanceof Error) {
        return {
          success: false,
          remaining: input,
          failedOn: {
            iterationCount,
            yielded: next.value,
          },
        };
      }

      return {
        success: true,
        remaining: input,
        result: next.value,
      };
    }

    const yielded = next.value as ParseItem;
    const choices =
      typeof yielded !== 'string' && (yielded as any)[Symbol.iterator]
        ? (yielded as Iterable<ParseItem>)
        : [yielded];

    for (const choice of choices) {
      if (typeof choice === 'string') {
        let found = false;
        const newInput = input.replace(choice, (_1, offset: number) => {
          found = offset === 0;
          return '';
        });
        if (found) {
          input = newInput;
          lastResult = choice;
          continue main;
        }
      } else if (choice instanceof RegExp) {
        if (['^', '$'].includes(choice.source[0]) === false) {
          throw new Error(`Regex must be from start: ${choice}`);
        }
        const match = input.match(choice);
        if (match) {
          lastResult = match;