minotor 3.0.1 → 3.0.2

package/dist/cli.mjs

@@ -10,6 +10,7 @@ import require$$2$1 from 'path';
 import require$$3$1 from 'events';
 import require$$4$1 from 'zlib';
 import require$$5, { Transform } from 'stream';
+import { performance } from 'perf_hooks';
 import repl from 'node:repl';
 
 /******************************************************************************
@@ -44,7 +45,7 @@ function __values(o) {
     if (m) return m.call(o);
     if (o && typeof o.length === "number") return {
         next: function () {
-            if (o && i >= o.length) o = undefined;
+            if (o && i >= o.length) o = void 0;
             return { value: o && o[i++], done: !o };
         }
     };
@@ -302,11 +303,24 @@ function requireHelp () {
 	class Help {
 	  constructor() {
 	    this.helpWidth = undefined;
+	    this.minWidthToWrap = 40;
 	    this.sortSubcommands = false;
 	    this.sortOptions = false;
 	    this.showGlobalOptions = false;
 	  }
 
+	  /**
+	   * prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
+	   * and just before calling `formatHelp()`.
+	   *
+	   * Commander just uses the helpWidth and the rest is provided for optional use by more complex subclasses.
+	   *
+	   * @param {{ error?: boolean, helpWidth?: number, outputHasColors?: boolean }} contextOptions
+	   */
+	  prepareContext(contextOptions) {
+	    this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+	  }
+
 	  /**
 	   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
 	   *
@@ -481,7 +495,12 @@ function requireHelp () {
 
 	  longestSubcommandTermLength(cmd, helper) {
 	    return helper.visibleCommands(cmd).reduce((max, command) => {
-	      return Math.max(max, helper.subcommandTerm(command).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(
+	          helper.styleSubcommandTerm(helper.subcommandTerm(command)),
+	        ),
+	      );
 	    }, 0);
 	  }
 
@@ -495,7 +514,10 @@ function requireHelp () {
 
 	  longestOptionTermLength(cmd, helper) {
 	    return helper.visibleOptions(cmd).reduce((max, option) => {
-	      return Math.max(max, helper.optionTerm(option).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))),
+	      );
 	    }, 0);
 	  }
 
@@ -509,7 +531,10 @@ function requireHelp () {
 
 	  longestGlobalOptionTermLength(cmd, helper) {
 	    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-	      return Math.max(max, helper.optionTerm(option).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))),
+	      );
 	    }, 0);
 	  }
 
@@ -523,7 +548,12 @@ function requireHelp () {
 
 	  longestArgumentTermLength(cmd, helper) {
 	    return helper.visibleArguments(cmd).reduce((max, argument) => {
-	      return Math.max(max, helper.argumentTerm(argument).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(
+	          helper.styleArgumentTerm(helper.argumentTerm(argument)),
+	        ),
+	      );
 	    }, 0);
 	  }
 
@@ -613,7 +643,11 @@ function requireHelp () {
 	      extraInfo.push(`env: ${option.envVar}`);
 	    }
 	    if (extraInfo.length > 0) {
-	      return `${option.description} (${extraInfo.join(', ')})`;
+	      const extraDescription = `(${extraInfo.join(', ')})`;
+	      if (option.description) {
+	        return `${option.description} ${extraDescription}`;
+	      }
+	      return extraDescription;
 	    }
 
 	    return option.description;
@@ -640,15 +674,55 @@ function requireHelp () {
 	      );
 	    }
 	    if (extraInfo.length > 0) {
-	      const extraDescripton = `(${extraInfo.join(', ')})`;
+	      const extraDescription = `(${extraInfo.join(', ')})`;
 	      if (argument.description) {
-	        return `${argument.description} ${extraDescripton}`;
+	        return `${argument.description} ${extraDescription}`;
 	      }
-	      return extraDescripton;
+	      return extraDescription;
 	    }
 	    return argument.description;
 	  }
 
+	  /**
+	   * Format a list of items, given a heading and an array of formatted items.
+	   *
+	   * @param {string} heading
+	   * @param {string[]} items
+	   * @param {Help} helper
+	   * @returns string[]
+	   */
+	  formatItemList(heading, items, helper) {
+	    if (items.length === 0) return [];
+
+	    return [helper.styleTitle(heading), ...items, ''];
+	  }
+
+	  /**
+	   * Group items by their help group heading.
+	   *
+	   * @param {Command[] | Option[]} unsortedItems
+	   * @param {Command[] | Option[]} visibleItems
+	   * @param {Function} getGroup
+	   * @returns {Map<string, Command[] | Option[]>}
+	   */
+	  groupItems(unsortedItems, visibleItems, getGroup) {
+	    const result = new Map();
+	    // Add groups in order of appearance in unsortedItems.
+	    unsortedItems.forEach((item) => {
+	      const group = getGroup(item);
+	      if (!result.has(group)) result.set(group, []);
+	    });
+	    // Add items in order of appearance in visibleItems.
+	    visibleItems.forEach((item) => {
+	      const group = getGroup(item);
+	      if (!result.has(group)) {
+	        result.set(group, []);
+	      }
+	      result.get(group).push(item);
+	    });
+	    return result;
+	  }
+
 	  /**
 	   * Generate the built-in help text.
 	   *
@@ -659,90 +733,171 @@ function requireHelp () {
 
 	  formatHelp(cmd, helper) {
 	    const termWidth = helper.padWidth(cmd, helper);
-	    const helpWidth = helper.helpWidth || 80;
-	    const itemIndentWidth = 2;
-	    const itemSeparatorWidth = 2; // between term and description
-	    function formatItem(term, description) {
-	      if (description) {
-	        const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-	        return helper.wrap(
-	          fullText,
-	          helpWidth - itemIndentWidth,
-	          termWidth + itemSeparatorWidth,
-	        );
-	      }
-	      return term;
-	    }
-	    function formatList(textArray) {
-	      return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
+	    const helpWidth = helper.helpWidth ?? 80; // in case prepareContext() was not called
+
+	    function callFormatItem(term, description) {
+	      return helper.formatItem(term, termWidth, description, helper);
 	    }
 
 	    // Usage
-	    let output = [`Usage: ${helper.commandUsage(cmd)}`, ''];
+	    let output = [
+	      `${helper.styleTitle('Usage:')} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+	      '',
+	    ];
 
 	    // Description
 	    const commandDescription = helper.commandDescription(cmd);
 	    if (commandDescription.length > 0) {
 	      output = output.concat([
-	        helper.wrap(commandDescription, helpWidth, 0),
+	        helper.boxWrap(
+	          helper.styleCommandDescription(commandDescription),
+	          helpWidth,
+	        ),
 	        '',
 	      ]);
 	    }
 
 	    // Arguments
 	    const argumentList = helper.visibleArguments(cmd).map((argument) => {
-	      return formatItem(
-	        helper.argumentTerm(argument),
-	        helper.argumentDescription(argument),
+	      return callFormatItem(
+	        helper.styleArgumentTerm(helper.argumentTerm(argument)),
+	        helper.styleArgumentDescription(helper.argumentDescription(argument)),
 	      );
 	    });
-	    if (argumentList.length > 0) {
-	      output = output.concat(['Arguments:', formatList(argumentList), '']);
-	    }
+	    output = output.concat(
+	      this.formatItemList('Arguments:', argumentList, helper),
+	    );
 
 	    // Options
-	    const optionList = helper.visibleOptions(cmd).map((option) => {
-	      return formatItem(
-	        helper.optionTerm(option),
-	        helper.optionDescription(option),
-	      );
+	    const optionGroups = this.groupItems(
+	      cmd.options,
+	      helper.visibleOptions(cmd),
+	      (option) => option.helpGroupHeading ?? 'Options:',
+	    );
+	    optionGroups.forEach((options, group) => {
+	      const optionList = options.map((option) => {
+	        return callFormatItem(
+	          helper.styleOptionTerm(helper.optionTerm(option)),
+	          helper.styleOptionDescription(helper.optionDescription(option)),
+	        );
+	      });
+	      output = output.concat(this.formatItemList(group, optionList, helper));
 	    });
-	    if (optionList.length > 0) {
-	      output = output.concat(['Options:', formatList(optionList), '']);
-	    }
 
-	    if (this.showGlobalOptions) {
+	    if (helper.showGlobalOptions) {
 	      const globalOptionList = helper
 	        .visibleGlobalOptions(cmd)
 	        .map((option) => {
-	          return formatItem(
-	            helper.optionTerm(option),
-	            helper.optionDescription(option),
+	          return callFormatItem(
+	            helper.styleOptionTerm(helper.optionTerm(option)),
+	            helper.styleOptionDescription(helper.optionDescription(option)),
 	          );
 	        });
-	      if (globalOptionList.length > 0) {
-	        output = output.concat([
-	          'Global Options:',
-	          formatList(globalOptionList),
-	          '',
-	        ]);
-	      }
+	      output = output.concat(
+	        this.formatItemList('Global Options:', globalOptionList, helper),
+	      );
 	    }
 
 	    // Commands
-	    const commandList = helper.visibleCommands(cmd).map((cmd) => {
-	      return formatItem(
-	        helper.subcommandTerm(cmd),
-	        helper.subcommandDescription(cmd),
-	      );
+	    const commandGroups = this.groupItems(
+	      cmd.commands,
+	      helper.visibleCommands(cmd),
+	      (sub) => sub.helpGroup() || 'Commands:',
+	    );
+	    commandGroups.forEach((commands, group) => {
+	      const commandList = commands.map((sub) => {
+	        return callFormatItem(
+	          helper.styleSubcommandTerm(helper.subcommandTerm(sub)),
+	          helper.styleSubcommandDescription(helper.subcommandDescription(sub)),
+	        );
+	      });
+	      output = output.concat(this.formatItemList(group, commandList, helper));
 	    });
-	    if (commandList.length > 0) {
-	      output = output.concat(['Commands:', formatList(commandList), '']);
-	    }
 
 	    return output.join('\n');
 	  }
 
+	  /**
+	   * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+	   *
+	   * @param {string} str
+	   * @returns {number}
+	   */
+	  displayWidth(str) {
+	    return stripColor(str).length;
+	  }
+
+	  /**
+	   * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+	   *
+	   * @param {string} str
+	   * @returns {string}
+	   */
+	  styleTitle(str) {
+	    return str;
+	  }
+
+	  styleUsage(str) {
+	    // Usage has lots of parts the user might like to color separately! Assume default usage string which is formed like:
+	    //    command subcommand [options] [command] <foo> [bar]
+	    return str
+	      .split(' ')
+	      .map((word) => {
+	        if (word === '[options]') return this.styleOptionText(word);
+	        if (word === '[command]') return this.styleSubcommandText(word);
+	        if (word[0] === '[' || word[0] === '<')
+	          return this.styleArgumentText(word);
+	        return this.styleCommandText(word); // Restrict to initial words?
+	      })
+	      .join(' ');
+	  }
+	  styleCommandDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleOptionDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleSubcommandDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleArgumentDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleDescriptionText(str) {
+	    return str;
+	  }
+	  styleOptionTerm(str) {
+	    return this.styleOptionText(str);
+	  }
+	  styleSubcommandTerm(str) {
+	    // This is very like usage with lots of parts! Assume default string which is formed like:
+	    //    subcommand [options] <foo> [bar]
+	    return str
+	      .split(' ')
+	      .map((word) => {
+	        if (word === '[options]') return this.styleOptionText(word);
+	        if (word[0] === '[' || word[0] === '<')
+	          return this.styleArgumentText(word);
+	        return this.styleSubcommandText(word); // Restrict to initial words?
+	      })
+	      .join(' ');
+	  }
+	  styleArgumentTerm(str) {
+	    return this.styleArgumentText(str);
+	  }
+	  styleOptionText(str) {
+	    return str;
+	  }
+	  styleArgumentText(str) {
+	    return str;
+	  }
+	  styleSubcommandText(str) {
+	    return str;
+	  }
+	  styleCommandText(str) {
+	    return str;
+	  }
+
 	  /**
 	   * Calculate the pad width from the maximum term length.
 	   *
@@ -761,53 +916,126 @@ function requireHelp () {
 	  }
 
 	  /**
-	   * Wrap the given string to width characters per line, with lines after the first indented.
-	   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+	   * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
 	   *
 	   * @param {string} str
-	   * @param {number} width
-	   * @param {number} indent
-	   * @param {number} [minColumnWidth=40]
-	   * @return {string}
-	   *
+	   * @returns {boolean}
 	   */
+	  preformatted(str) {
+	    return /\n[^\S\r\n]/.test(str);
+	  }
 
-	  wrap(str, width, indent, minColumnWidth = 40) {
-	    // Full \s characters, minus the linefeeds.
-	    const indents =
-	      ' \\f\\t\\v\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff';
-	    // Detect manually wrapped and indented strings by searching for line break followed by spaces.
-	    const manualIndent = new RegExp(`[\\n][${indents}]+`);
-	    if (str.match(manualIndent)) return str;
-	    // Do not wrap if not enough room for a wrapped column of text (as could end up with a word per line).
-	    const columnWidth = width - indent;
-	    if (columnWidth < minColumnWidth) return str;
-
-	    const leadingStr = str.slice(0, indent);
-	    const columnText = str.slice(indent).replace('\r\n', '\n');
-	    const indentString = ' '.repeat(indent);
-	    const zeroWidthSpace = '\u200B';
-	    const breaks = `\\s${zeroWidthSpace}`;
-	    // Match line end (so empty lines don't collapse),
-	    // or as much text as will fit in column, or excess text up to first break.
-	    const regex = new RegExp(
-	      `\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`,
-	      'g',
+	  /**
+	   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+	   *
+	   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+	   *   TTT  DDD DDDD
+	   *        DD DDD
+	   *
+	   * @param {string} term
+	   * @param {number} termWidth
+	   * @param {string} description
+	   * @param {Help} helper
+	   * @returns {string}
+	   */
+	  formatItem(term, termWidth, description, helper) {
+	    const itemIndent = 2;
+	    const itemIndentStr = ' '.repeat(itemIndent);
+	    if (!description) return itemIndentStr + term;
+
+	    // Pad the term out to a consistent width, so descriptions are aligned.
+	    const paddedTerm = term.padEnd(
+	      termWidth + term.length - helper.displayWidth(term),
 	    );
-	    const lines = columnText.match(regex) || [];
+
+	    // Format the description.
+	    const spacerWidth = 2; // between term and description
+	    const helpWidth = this.helpWidth ?? 80; // in case prepareContext() was not called
+	    const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+	    let formattedDescription;
+	    if (
+	      remainingWidth < this.minWidthToWrap ||
+	      helper.preformatted(description)
+	    ) {
+	      formattedDescription = description;
+	    } else {
+	      const wrappedDescription = helper.boxWrap(description, remainingWidth);
+	      formattedDescription = wrappedDescription.replace(
+	        /\n/g,
+	        '\n' + ' '.repeat(termWidth + spacerWidth),
+	      );
+	    }
+
+	    // Construct and overall indent.
 	    return (
-	      leadingStr +
-	      lines
-	        .map((line, i) => {
-	          if (line === '\n') return ''; // preserve empty lines
-	          return (i > 0 ? indentString : '') + line.trimEnd();
-	        })
-	        .join('\n')
+	      itemIndentStr +
+	      paddedTerm +
+	      ' '.repeat(spacerWidth) +
+	      formattedDescription.replace(/\n/g, `\n${itemIndentStr}`)
 	    );
 	  }
+
+	  /**
+	   * Wrap a string at whitespace, preserving existing line breaks.
+	   * Wrapping is skipped if the width is less than `minWidthToWrap`.
+	   *
+	   * @param {string} str
+	   * @param {number} width
+	   * @returns {string}
+	   */
+	  boxWrap(str, width) {
+	    if (width < this.minWidthToWrap) return str;
+
+	    const rawLines = str.split(/\r\n|\n/);
+	    // split up text by whitespace
+	    const chunkPattern = /[\s]*[^\s]+/g;
+	    const wrappedLines = [];
+	    rawLines.forEach((line) => {
+	      const chunks = line.match(chunkPattern);
+	      if (chunks === null) {
+	        wrappedLines.push('');
+	        return;
+	      }
+
+	      let sumChunks = [chunks.shift()];
+	      let sumWidth = this.displayWidth(sumChunks[0]);
+	      chunks.forEach((chunk) => {
+	        const visibleWidth = this.displayWidth(chunk);
+	        // Accumulate chunks while they fit into width.
+	        if (sumWidth + visibleWidth <= width) {
+	          sumChunks.push(chunk);
+	          sumWidth += visibleWidth;
+	          return;
+	        }
+	        wrappedLines.push(sumChunks.join(''));
+
+	        const nextChunk = chunk.trimStart(); // trim space at line break
+	        sumChunks = [nextChunk];
+	        sumWidth = this.displayWidth(nextChunk);
+	      });
+	      wrappedLines.push(sumChunks.join(''));
+	    });
+
+	    return wrappedLines.join('\n');
+	  }
+	}
+
+	/**
+	 * Strip style ANSI escape sequences from the string. In particular, SGR (Select Graphic Rendition) codes.
+	 *
+	 * @param {string} str
+	 * @returns {string}
+	 * @package
+	 */
+
+	function stripColor(str) {
+	  // eslint-disable-next-line no-control-regex
+	  const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+	  return str.replace(sgrPattern, '');
 	}
 
 	help.Help = Help;
+	help.stripColor = stripColor;
 	return help;
 }
 
@@ -838,7 +1066,7 @@ function requireOption () {
 	    this.variadic = /\w\.\.\.[>\]]$/.test(flags); // The option can take multiple values.
 	    this.mandatory = false; // The option must have a value after parsing, which usually means it must be specified on command line.
 	    const optionFlags = splitOptionFlags(flags);
-	    this.short = optionFlags.shortFlag;
+	    this.short = optionFlags.shortFlag; // May be a short flag, undefined, or even a long flag (if option has two long flags).
 	    this.long = optionFlags.longFlag;
 	    this.negate = false;
 	    if (this.long) {
@@ -853,6 +1081,7 @@ function requireOption () {
 	    this.argChoices = undefined;
 	    this.conflictsWith = [];
 	    this.implied = undefined;
+	    this.helpGroupHeading = undefined; // soft initialised when option added to command
 	  }
 
 	  /**
@@ -1027,13 +1256,27 @@ function requireOption () {
 
 	  /**
 	   * Return option name, in a camelcase format that can be used
-	   * as a object attribute key.
+	   * as an object attribute key.
 	   *
 	   * @return {string}
 	   */
 
 	  attributeName() {
-	    return camelcase(this.name().replace(/^no-/, ''));
+	    if (this.negate) {
+	      return camelcase(this.name().replace(/^no-/, ''));
+	    }
+	    return camelcase(this.name());
+	  }
+
+	  /**
+	   * Set the help group heading.
+	   *
+	   * @param {string} heading
+	   * @return {Option}
+	   */
+	  helpGroup(heading) {
+	    this.helpGroupHeading = heading;
+	    return this;
 	  }
 
 	  /**
@@ -1132,17 +1375,51 @@ function requireOption () {
 	function splitOptionFlags(flags) {
 	  let shortFlag;
 	  let longFlag;
-	  // Use original very loose parsing to maintain backwards compatibility for now,
-	  // which allowed for example unintended `-sw, --short-word` [sic].
-	  const flagParts = flags.split(/[ |,]+/);
-	  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
+	  // short flag, single dash and single character
+	  const shortFlagExp = /^-[^-]$/;
+	  // long flag, double dash and at least one character
+	  const longFlagExp = /^--[^-]/;
+
+	  const flagParts = flags.split(/[ |,]+/).concat('guard');
+	  // Normal is short and/or long.
+	  if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
+	  if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
+	  // Long then short. Rarely used but fine.
+	  if (!shortFlag && shortFlagExp.test(flagParts[0]))
 	    shortFlag = flagParts.shift();
-	  longFlag = flagParts.shift();
-	  // Add support for lone short flag without significantly changing parsing!
-	  if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+	  // Allow two long flags, like '--ws, --workspace'
+	  // This is the supported way to have a shortish option flag.
+	  if (!shortFlag && longFlagExp.test(flagParts[0])) {
 	    shortFlag = longFlag;
-	    longFlag = undefined;
+	    longFlag = flagParts.shift();
+	  }
+
+	  // Check for unprocessed flag. Fail noisily rather than silently ignore.
+	  if (flagParts[0].startsWith('-')) {
+	    const unsupportedFlag = flagParts[0];
+	    const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+	    if (/^-[^-][^-]/.test(unsupportedFlag))
+	      throw new Error(
+	        `${baseError}
+- a short flag is a single dash and a single character
+  - either use a single dash and a single character (for a short flag)
+  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`,
+	      );
+	    if (shortFlagExp.test(unsupportedFlag))
+	      throw new Error(`${baseError}
+- too many short flags`);
+	    if (longFlagExp.test(unsupportedFlag))
+	      throw new Error(`${baseError}
+- too many long flags`);
+
+	    throw new Error(`${baseError}
+- unrecognised flag format`);
 	  }
+	  if (shortFlag === undefined && longFlag === undefined)
+	    throw new Error(
+	      `option creation failed due to no flags found in '${flags}'.`,
+	    );
+
 	  return { shortFlag, longFlag };
 	}
 
@@ -1275,7 +1552,7 @@ function requireCommand () {
 
 	const { Argument, humanReadableArgName } = requireArgument();
 	const { CommanderError } = requireError();
-	const { Help } = requireHelp();
+	const { Help, stripColor } = requireHelp();
 	const { Option, DualOptions } = requireOption();
 	const { suggestSimilar } = requireSuggestSimilar();
 
@@ -1294,7 +1571,7 @@ function requireCommand () {
 	    this.options = [];
 	    this.parent = null;
 	    this._allowUnknownOption = false;
-	    this._allowExcessArguments = true;
+	    this._allowExcessArguments = false;
 	    /** @type {Argument[]} */
 	    this.registeredArguments = [];
 	    this._args = this.registeredArguments; // deprecated old name
@@ -1324,16 +1601,22 @@ function requireCommand () {
 	    /** @type {(boolean | string)} */
 	    this._showHelpAfterError = false;
 	    this._showSuggestionAfterError = true;
+	    this._savedState = null; // used in save/restoreStateBeforeParse
 
-	    // see .configureOutput() for docs
+	    // see configureOutput() for docs
 	    this._outputConfiguration = {
 	      writeOut: (str) => process.stdout.write(str),
 	      writeErr: (str) => process.stderr.write(str),
+	      outputError: (str, write) => write(str),
 	      getOutHelpWidth: () =>
 	        process.stdout.isTTY ? process.stdout.columns : undefined,
 	      getErrHelpWidth: () =>
 	        process.stderr.isTTY ? process.stderr.columns : undefined,
-	      outputError: (str, write) => write(str),
+	      getOutHasColors: () =>
+	        useColor() ?? (process.stdout.isTTY && process.stdout.hasColors?.()),
+	      getErrHasColors: () =>
+	        useColor() ?? (process.stderr.isTTY && process.stderr.hasColors?.()),
+	      stripColor: (str) => stripColor(str),
 	    };
 
 	    this._hidden = false;
@@ -1343,6 +1626,12 @@ function requireCommand () {
 	    /** @type {Command} */
 	    this._helpCommand = undefined; // lazy initialised, inherited
 	    this._helpConfiguration = {};
+	    /** @type {string | undefined} */
+	    this._helpGroupHeading = undefined; // soft initialised when added to parent
+	    /** @type {string | undefined} */
+	    this._defaultCommandGroup = undefined;
+	    /** @type {string | undefined} */
+	    this._defaultOptionGroup = undefined;
 	  }
 
 	  /**
@@ -1482,14 +1771,18 @@ function requireCommand () {
 	   *
 	   * The configuration properties are all functions:
 	   *
-	   *     // functions to change where being written, stdout and stderr
+	   *     // change how output being written, defaults to stdout and stderr
 	   *     writeOut(str)
 	   *     writeErr(str)
-	   *     // matching functions to specify width for wrapping help
+	   *     // change how output being written for errors, defaults to writeErr
+	   *     outputError(str, write) // used for displaying errors and not used for displaying help
+	   *     // specify width for wrapping help
 	   *     getOutHelpWidth()
 	   *     getErrHelpWidth()
-	   *     // functions based on what is being written out
-	   *     outputError(str, write) // used for displaying errors, and not used for displaying help
+	   *     // color support, currently only used with Help
+	   *     getOutHasColors()
+	   *     getErrHasColors()
+	   *     stripColor() // used to remove ANSI escape codes if output does not have colors
 	   *
 	   * @param {object} [configuration] - configuration options
 	   * @return {(Command | object)} `this` command for chaining, or stored configuration
@@ -1498,7 +1791,11 @@ function requireCommand () {
 	  configureOutput(configuration) {
 	    if (configuration === undefined) return this._outputConfiguration;
 
-	    Object.assign(this._outputConfiguration, configuration);
+	    this._outputConfiguration = Object.assign(
+	      {},
+	      this._outputConfiguration,
+	      configuration,
+	    );
 	    return this;
 	  }
 
@@ -1579,16 +1876,16 @@ function requireCommand () {
 	   *
 	   * @param {string} name
 	   * @param {string} [description]
-	   * @param {(Function|*)} [fn] - custom argument processing function
+	   * @param {(Function|*)} [parseArg] - custom argument processing function or default value
 	   * @param {*} [defaultValue]
 	   * @return {Command} `this` command for chaining
 	   */
-	  argument(name, description, fn, defaultValue) {
+	  argument(name, description, parseArg, defaultValue) {
 	    const argument = this.createArgument(name, description);
-	    if (typeof fn === 'function') {
-	      argument.default(defaultValue).argParser(fn);
+	    if (typeof parseArg === 'function') {
+	      argument.default(defaultValue).argParser(parseArg);
 	    } else {
-	      argument.default(fn);
+	      argument.default(parseArg);
 	    }
 	    this.addArgument(argument);
 	    return this;
@@ -1659,11 +1956,15 @@ function requireCommand () {
 	  helpCommand(enableOrNameAndArgs, description) {
 	    if (typeof enableOrNameAndArgs === 'boolean') {
 	      this._addImplicitHelpCommand = enableOrNameAndArgs;
+	      if (enableOrNameAndArgs && this._defaultCommandGroup) {
+	        // make the command to store the group
+	        this._initCommandGroup(this._getHelpCommand());
+	      }
 	      return this;
 	    }
 
-	    enableOrNameAndArgs = enableOrNameAndArgs ?? 'help [command]';
-	    const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+	    const nameAndArgs = enableOrNameAndArgs ?? 'help [command]';
+	    const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
 	    const helpDescription = description ?? 'display help for command';
 
 	    const helpCommand = this.createCommand(helpName);
@@ -1673,6 +1974,8 @@ function requireCommand () {
 
 	    this._addImplicitHelpCommand = true;
 	    this._helpCommand = helpCommand;
+	    // init group unless lazy create
+	    if (enableOrNameAndArgs || description) this._initCommandGroup(helpCommand);
 
 	    return this;
 	  }
@@ -1694,6 +1997,7 @@ function requireCommand () {
 
 	    this._addImplicitHelpCommand = true;
 	    this._helpCommand = helpCommand;
+	    this._initCommandGroup(helpCommand);
 	    return this;
 	  }
 
@@ -1870,6 +2174,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 -  already used by option '${matchingOption.flags}'`);
 	    }
 
+	    this._initOptionGroup(option);
 	    this.options.push(option);
 	  }
 
@@ -1897,6 +2202,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      );
 	    }
 
+	    this._initCommandGroup(command);
 	    this.commands.push(command);
 	  }
 
@@ -2013,7 +2319,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   * @example
 	   * program
 	   *     .option('-p, --pepper', 'add pepper')
-	   *     .option('-p, --pizza-type <TYPE>', 'type of pizza') // required option-argument
+	   *     .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
 	   *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
 	   *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
 	   *
@@ -2327,6 +2633,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   */
 
 	  parse(argv, parseOptions) {
+	    this._prepareForParse();
 	    const userArgs = this._prepareUserArgs(argv, parseOptions);
 	    this._parseCommand([], userArgs);
 
@@ -2355,12 +2662,82 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   */
 
 	  async parseAsync(argv, parseOptions) {
+	    this._prepareForParse();
 	    const userArgs = this._prepareUserArgs(argv, parseOptions);
 	    await this._parseCommand([], userArgs);
 
 	    return this;
 	  }
 
+	  _prepareForParse() {
+	    if (this._savedState === null) {
+	      this.saveStateBeforeParse();
+	    } else {
+	      this.restoreStateBeforeParse();
+	    }
+	  }
+
+	  /**
+	   * Called the first time parse is called to save state and allow a restore before subsequent calls to parse.
+	   * Not usually called directly, but available for subclasses to save their custom state.
+	   *
+	   * This is called in a lazy way. Only commands used in parsing chain will have state saved.
+	   */
+	  saveStateBeforeParse() {
+	    this._savedState = {
+	      // name is stable if supplied by author, but may be unspecified for root command and deduced during parsing
+	      _name: this._name,
+	      // option values before parse have default values (including false for negated options)
+	      // shallow clones
+	      _optionValues: { ...this._optionValues },
+	      _optionValueSources: { ...this._optionValueSources },
+	    };
+	  }
+
+	  /**
+	   * Restore state before parse for calls after the first.
+	   * Not usually called directly, but available for subclasses to save their custom state.
+	   *
+	   * This is called in a lazy way. Only commands used in parsing chain will have state restored.
+	   */
+	  restoreStateBeforeParse() {
+	    if (this._storeOptionsAsProperties)
+	      throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
+- either make a new Command for each call to parse, or stop storing options as properties`);
+
+	    // clear state from _prepareUserArgs
+	    this._name = this._savedState._name;
+	    this._scriptPath = null;
+	    this.rawArgs = [];
+	    // clear state from setOptionValueWithSource
+	    this._optionValues = { ...this._savedState._optionValues };
+	    this._optionValueSources = { ...this._savedState._optionValueSources };
+	    // clear state from _parseCommand
+	    this.args = [];
+	    // clear state from _processArguments
+	    this.processedArgs = [];
+	  }
+
+	  /**
+	   * Throw if expected executable is missing. Add lots of help for author.
+	   *
+	   * @param {string} executableFile
+	   * @param {string} executableDir
+	   * @param {string} subcommandName
+	   */
+	  _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
+	    if (fs.existsSync(executableFile)) return;
+
+	    const executableDirMessage = executableDir
+	      ? `searched for local subcommand relative to directory '${executableDir}'`
+	      : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';
+	    const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+	    throw new Error(executableMissing);
+	  }
+
 	  /**
 	   * Execute a sub-command executable.
 	   *
@@ -2401,7 +2778,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      let resolvedScriptPath; // resolve possible symlink for installed npm binary
 	      try {
 	        resolvedScriptPath = fs.realpathSync(this._scriptPath);
-	      } catch (err) {
+	      } catch {
 	        resolvedScriptPath = this._scriptPath;
 	      }
 	      executableDir = path.resolve(
@@ -2444,6 +2821,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	        proc = childProcess.spawn(executableFile, args, { stdio: 'inherit' });
 	      }
 	    } else {
+	      this._checkForMissingExecutable(
+	        executableFile,
+	        executableDir,
+	        subcommand._name,
+	      );
 	      args.unshift(executableFile);
 	      // add executable arguments to spawn
 	      args = incrementNodeInspectorPort(process.execArgv).concat(args);
@@ -2482,14 +2864,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    proc.on('error', (err) => {
 	      // @ts-ignore: because err.code is an unknown property
 	      if (err.code === 'ENOENT') {
-	        const executableDirMessage = executableDir
-	          ? `searched for local subcommand relative to directory '${executableDir}'`
-	          : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';
-	        const executableMissing = `'${executableFile}' does not exist
- - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-	        throw new Error(executableMissing);
+	        this._checkForMissingExecutable(
+	          executableFile,
+	          executableDir,
+	          subcommand._name,
+	        );
 	        // @ts-ignore: because err.code is an unknown property
 	      } else if (err.code === 'EACCES') {
 	        throw new Error(`'${executableFile}' not executable`);
@@ -2519,6 +2898,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    const subCommand = this._findCommand(commandName);
 	    if (!subCommand) this.help({ error: true });
 
+	    subCommand._prepareForParse();
 	    let promiseChain;
 	    promiseChain = this._chainOrCallSubCommandHook(
 	      promiseChain,
@@ -2896,6 +3276,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   * Parse options from `argv` removing known options,
 	   * and return argv split into operands and unknown arguments.
 	   *
+	   * Side effects: modifies command by storing options. Does not reset state if called again.
+	   *
 	   * Examples:
 	   *
 	   *     argv => operands, unknown
@@ -2918,6 +3300,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      return arg.length > 1 && arg[0] === '-';
 	    }
 
+	    const negativeNumberArg = (arg) => {
+	      // return false if not a negative number
+	      if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false;
+	      // negative number is ok unless digit used as an option in command hierarchy
+	      return !this._getCommandAndAncestors().some((cmd) =>
+	        cmd.options
+	          .map((opt) => opt.short)
+	          .some((short) => /^-\d$/.test(short)),
+	      );
+	    };
+
 	    // parse options
 	    let activeVariadicOption = null;
 	    while (args.length) {
@@ -2930,7 +3323,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	        break;
 	      }
 
-	      if (activeVariadicOption && !maybeOption(arg)) {
+	      if (
+	        activeVariadicOption &&
+	        (!maybeOption(arg) || negativeNumberArg(arg))
+	      ) {
 	        this.emit(`option:${activeVariadicOption.name()}`, arg);
 	        continue;
 	      }
@@ -2947,7 +3343,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	          } else if (option.optional) {
 	            let value = null;
 	            // historical behaviour is optional value is following arg unless an option
-	            if (args.length > 0 && !maybeOption(args[0])) {
+	            if (
+	              args.length > 0 &&
+	              (!maybeOption(args[0]) || negativeNumberArg(args[0]))
+	            ) {
 	              value = args.shift();
 	            }
 	            this.emit(`option:${option.name()}`, value);
@@ -2993,7 +3392,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      // Might be a command-argument, or subcommand option, or unknown option, or help command or option.
 
 	      // An unknown option means further arguments also classified as unknown so can be reprocessed by subcommands.
-	      if (maybeOption(arg)) {
+	      // A negative number in a leaf command is not an unknown option.
+	      if (
+	        dest === operands &&
+	        maybeOption(arg) &&
+	        !(this.commands.length === 0 && negativeNumberArg(arg))
+	      ) {
 	        dest = unknown;
 	      }
 
@@ -3475,6 +3879,75 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    return this;
 	  }
 
+	  /**
+	   * Set/get the help group heading for this subcommand in parent command's help.
+	   *
+	   * @param {string} [heading]
+	   * @return {Command | string}
+	   */
+
+	  helpGroup(heading) {
+	    if (heading === undefined) return this._helpGroupHeading ?? '';
+	    this._helpGroupHeading = heading;
+	    return this;
+	  }
+
+	  /**
+	   * Set/get the default help group heading for subcommands added to this command.
+	   * (This does not override a group set directly on the subcommand using .helpGroup().)
+	   *
+	   * @example
+	   * program.commandsGroup('Development Commands:);
+	   * program.command('watch')...
+	   * program.command('lint')...
+	   * ...
+	   *
+	   * @param {string} [heading]
+	   * @returns {Command | string}
+	   */
+	  commandsGroup(heading) {
+	    if (heading === undefined) return this._defaultCommandGroup ?? '';
+	    this._defaultCommandGroup = heading;
+	    return this;
+	  }
+
+	  /**
+	   * Set/get the default help group heading for options added to this command.
+	   * (This does not override a group set directly on the option using .helpGroup().)
+	   *
+	   * @example
+	   * program
+	   *   .optionsGroup('Development Options:')
+	   *   .option('-d, --debug', 'output extra debugging')
+	   *   .option('-p, --profile', 'output profiling information')
+	   *
+	   * @param {string} [heading]
+	   * @returns {Command | string}
+	   */
+	  optionsGroup(heading) {
+	    if (heading === undefined) return this._defaultOptionGroup ?? '';
+	    this._defaultOptionGroup = heading;
+	    return this;
+	  }
+
+	  /**
+	   * @param {Option} option
+	   * @private
+	   */
+	  _initOptionGroup(option) {
+	    if (this._defaultOptionGroup && !option.helpGroupHeading)
+	      option.helpGroup(this._defaultOptionGroup);
+	  }
+
+	  /**
+	   * @param {Command} cmd
+	   * @private
+	   */
+	  _initCommandGroup(cmd) {
+	    if (this._defaultCommandGroup && !cmd.helpGroup())
+	      cmd.helpGroup(this._defaultCommandGroup);
+	  }
+
 	  /**
 	   * Set the name of the command from script filename, such as process.argv[1],
 	   * or require.main.filename, or __filename.
@@ -3521,31 +3994,49 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
 	  helpInformation(contextOptions) {
 	    const helper = this.createHelp();
-	    if (helper.helpWidth === undefined) {
-	      helper.helpWidth =
-	        contextOptions && contextOptions.error
-	          ? this._outputConfiguration.getErrHelpWidth()
-	          : this._outputConfiguration.getOutHelpWidth();
-	    }
-	    return helper.formatHelp(this, helper);
+	    const context = this._getOutputContext(contextOptions);
+	    helper.prepareContext({
+	      error: context.error,
+	      helpWidth: context.helpWidth,
+	      outputHasColors: context.hasColors,
+	    });
+	    const text = helper.formatHelp(this, helper);
+	    if (context.hasColors) return text;
+	    return this._outputConfiguration.stripColor(text);
 	  }
 
 	  /**
+	   * @typedef HelpContext
+	   * @type {object}
+	   * @property {boolean} error
+	   * @property {number} helpWidth
+	   * @property {boolean} hasColors
+	   * @property {function} write - includes stripColor if needed
+	   *
+	   * @returns {HelpContext}
 	   * @private
 	   */
 
-	  _getHelpContext(contextOptions) {
+	  _getOutputContext(contextOptions) {
 	    contextOptions = contextOptions || {};
-	    const context = { error: !!contextOptions.error };
-	    let write;
-	    if (context.error) {
-	      write = (arg) => this._outputConfiguration.writeErr(arg);
+	    const error = !!contextOptions.error;
+	    let baseWrite;
+	    let hasColors;
+	    let helpWidth;
+	    if (error) {
+	      baseWrite = (str) => this._outputConfiguration.writeErr(str);
+	      hasColors = this._outputConfiguration.getErrHasColors();
+	      helpWidth = this._outputConfiguration.getErrHelpWidth();
 	    } else {
-	      write = (arg) => this._outputConfiguration.writeOut(arg);
+	      baseWrite = (str) => this._outputConfiguration.writeOut(str);
+	      hasColors = this._outputConfiguration.getOutHasColors();
+	      helpWidth = this._outputConfiguration.getOutHelpWidth();
 	    }
-	    context.write = contextOptions.write || write;
-	    context.command = this;
-	    return context;
+	    const write = (str) => {
+	      if (!hasColors) str = this._outputConfiguration.stripColor(str);
+	      return baseWrite(str);
+	    };
+	    return { error, write, hasColors, helpWidth };
 	  }
 
 	  /**
@@ -3562,14 +4053,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      deprecatedCallback = contextOptions;
 	      contextOptions = undefined;
 	    }
-	    const context = this._getHelpContext(contextOptions);
+
+	    const outputContext = this._getOutputContext(contextOptions);
+	    /** @type {HelpTextEventContext} */
+	    const eventContext = {
+	      error: outputContext.error,
+	      write: outputContext.write,
+	      command: this,
+	    };
 
 	    this._getCommandAndAncestors()
 	      .reverse()
-	      .forEach((command) => command.emit('beforeAllHelp', context));
-	    this.emit('beforeHelp', context);
+	      .forEach((command) => command.emit('beforeAllHelp', eventContext));
+	    this.emit('beforeHelp', eventContext);
 
-	    let helpInformation = this.helpInformation(context);
+	    let helpInformation = this.helpInformation({ error: outputContext.error });
 	    if (deprecatedCallback) {
 	      helpInformation = deprecatedCallback(helpInformation);
 	      if (
@@ -3579,14 +4077,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	        throw new Error('outputHelp callback must return a string or a Buffer');
 	      }
 	    }
-	    context.write(helpInformation);
+	    outputContext.write(helpInformation);
 
 	    if (this._getHelpOption()?.long) {
 	      this.emit(this._getHelpOption().long); // deprecated
 	    }
-	    this.emit('afterHelp', context);
+	    this.emit('afterHelp', eventContext);
 	    this._getCommandAndAncestors().forEach((command) =>
-	      command.emit('afterAllHelp', context),
+	      command.emit('afterAllHelp', eventContext),
 	    );
 	  }
 
@@ -3604,10 +4102,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   */
 
 	  helpOption(flags, description) {
-	    // Support disabling built-in help option.
+	    // Support enabling/disabling built-in help option.
 	    if (typeof flags === 'boolean') {
 	      if (flags) {
-	        this._helpOption = this._helpOption ?? undefined; // preserve existing option
+	        if (this._helpOption === null) this._helpOption = undefined; // reenable
+	        if (this._defaultOptionGroup) {
+	          // make the option to store the group
+	          this._initOptionGroup(this._getHelpOption());
+	        }
 	      } else {
 	        this._helpOption = null; // disable
 	      }
@@ -3615,9 +4117,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    }
 
 	    // Customise flags and description.
-	    flags = flags ?? '-h, --help';
-	    description = description ?? 'display help for command';
-	    this._helpOption = this.createOption(flags, description);
+	    this._helpOption = this.createOption(
+	      flags ?? '-h, --help',
+	      description ?? 'display help for command',
+	    );
+	    // init group unless lazy create
+	    if (flags || description) this._initOptionGroup(this._helpOption);
 
 	    return this;
 	  }
@@ -3646,6 +4151,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   */
 	  addHelpOption(option) {
 	    this._helpOption = option;
+	    this._initOptionGroup(option);
 	    return this;
 	  }
 
@@ -3659,7 +4165,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
 	  help(contextOptions) {
 	    this.outputHelp(contextOptions);
-	    let exitCode = process.exitCode || 0;
+	    let exitCode = Number(process.exitCode ?? 0); // process.exitCode does allow a string or an integer, but we prefer just a number
 	    if (
 	      exitCode === 0 &&
 	      contextOptions &&
@@ -3672,6 +4178,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    this._exit(exitCode, 'commander.help', '(outputHelp)');
 	  }
 
+	  /**
+	   * // Do a little typing to coordinate emit and listener for the help text events.
+	   * @typedef HelpTextEventContext
+	   * @type {object}
+	   * @property {boolean} error
+	   * @property {Command} command
+	   * @property {function} write
+	   */
+
 	  /**
 	   * Add additional text to be displayed with the built-in help.
 	   *
@@ -3682,14 +4197,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   * @param {(string | Function)} text - string to add, or a function returning a string
 	   * @return {Command} `this` command for chaining
 	   */
+
 	  addHelpText(position, text) {
 	    const allowedValues = ['beforeAll', 'before', 'after', 'afterAll'];
 	    if (!allowedValues.includes(position)) {
 	      throw new Error(`Unexpected value for position to addHelpText.
 Expecting one of '${allowedValues.join("', '")}'`);
 	    }
+
 	    const helpEvent = `${position}Help`;
-	    this.on(helpEvent, (context) => {
+	    this.on(helpEvent, (/** @type {HelpTextEventContext} */ context) => {
 	      let helpStr;
 	      if (typeof text === 'function') {
 	        helpStr = text({ error: context.error, command: context.command });
@@ -3773,7 +4290,36 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	  });
 	}
 
+	/**
+	 * @returns {boolean | undefined}
+	 * @package
+	 */
+	function useColor() {
+	  // Test for common conventions.
+	  // NB: the observed behaviour is in combination with how author adds color! For example:
+	  //   - we do not test NODE_DISABLE_COLORS, but util:styletext does
+	  //   - we do test NO_COLOR, but Chalk does not
+	  //
+	  // References:
+	  // https://no-color.org
+	  // https://bixense.com/clicolors/
+	  // https://github.com/nodejs/node/blob/0a00217a5f67ef4a22384cfc80eb6dd9a917fdc1/lib/internal/tty.js#L109
+	  // https://github.com/chalk/supports-color/blob/c214314a14bcb174b12b3014b2b0a8de375029ae/index.js#L33
+	  // (https://force-color.org recent web page from 2023, does not match major javascript implementations)
+
+	  if (
+	    process.env.NO_COLOR ||
+	    process.env.FORCE_COLOR === '0' ||
+	    process.env.FORCE_COLOR === 'false'
+	  )
+	    return false;
+	  if (process.env.FORCE_COLOR || process.env.CLICOLOR_FORCE !== undefined)
+	    return true;
+	  return undefined;
+	}
+
 	command.Command = Command;
+	command.useColor = useColor; // exporting for tests
 	return command;
 }
 
@@ -4591,12 +5137,13 @@ class SystemZone extends Zone {
   }
 }
 
-let dtfCache = {};
-function makeDTF(zone) {
-  if (!dtfCache[zone]) {
-    dtfCache[zone] = new Intl.DateTimeFormat("en-US", {
+const dtfCache = new Map();
+function makeDTF(zoneName) {
+  let dtf = dtfCache.get(zoneName);
+  if (dtf === undefined) {
+    dtf = new Intl.DateTimeFormat("en-US", {
       hour12: false,
-      timeZone: zone,
+      timeZone: zoneName,
       year: "numeric",
       month: "2-digit",
       day: "2-digit",
@@ -4605,8 +5152,9 @@ function makeDTF(zone) {
       second: "2-digit",
       era: "short",
     });
+    dtfCache.set(zoneName, dtf);
   }
-  return dtfCache[zone];
+  return dtf;
 }
 
 const typeToPos = {
@@ -4642,7 +5190,7 @@ function partsOffset(dtf, date) {
   return filled;
 }
 
-let ianaZoneCache = {};
+const ianaZoneCache = new Map();
 /**
  * A zone identified by an IANA identifier, like America/New_York
  * @implements {Zone}
@@ -4653,10 +5201,11 @@ class IANAZone extends Zone {
    * @return {IANAZone}
    */
   static create(name) {
-    if (!ianaZoneCache[name]) {
-      ianaZoneCache[name] = new IANAZone(name);
+    let zone = ianaZoneCache.get(name);
+    if (zone === undefined) {
+      ianaZoneCache.set(name, (zone = new IANAZone(name)));
     }
-    return ianaZoneCache[name];
+    return zone;
   }
 
   /**
@@ -4664,8 +5213,8 @@ class IANAZone extends Zone {
    * @return {void}
    */
   static resetCache() {
-    ianaZoneCache = {};
-    dtfCache = {};
+    ianaZoneCache.clear();
+    dtfCache.clear();
   }
 
   /**
@@ -4768,6 +5317,7 @@ class IANAZone extends Zone {
    * @return {number}
    */
   offset(ts) {
+    if (!this.valid) return NaN;
     const date = new Date(ts);
 
     if (isNaN(date)) return NaN;
@@ -4833,36 +5383,36 @@ function getCachedLF(locString, opts = {}) {
   return dtf;
 }
 
-let intlDTCache = {};
+const intlDTCache = new Map();
 function getCachedDTF(locString, opts = {}) {
   const key = JSON.stringify([locString, opts]);
-  let dtf = intlDTCache[key];
-  if (!dtf) {
+  let dtf = intlDTCache.get(key);
+  if (dtf === undefined) {
     dtf = new Intl.DateTimeFormat(locString, opts);
-    intlDTCache[key] = dtf;
+    intlDTCache.set(key, dtf);
   }
   return dtf;
 }
 
-let intlNumCache = {};
+const intlNumCache = new Map();
 function getCachedINF(locString, opts = {}) {
   const key = JSON.stringify([locString, opts]);
-  let inf = intlNumCache[key];
-  if (!inf) {
+  let inf = intlNumCache.get(key);
+  if (inf === undefined) {
     inf = new Intl.NumberFormat(locString, opts);
-    intlNumCache[key] = inf;
+    intlNumCache.set(key, inf);
   }
   return inf;
 }
 
-let intlRelCache = {};
+const intlRelCache = new Map();
 function getCachedRTF(locString, opts = {}) {
   const { base, ...cacheKeyOpts } = opts; // exclude `base` from the options
   const key = JSON.stringify([locString, cacheKeyOpts]);
-  let inf = intlRelCache[key];
-  if (!inf) {
+  let inf = intlRelCache.get(key);
+  if (inf === undefined) {
     inf = new Intl.RelativeTimeFormat(locString, opts);
-    intlRelCache[key] = inf;
+    intlRelCache.set(key, inf);
   }
   return inf;
 }
@@ -4877,14 +5427,28 @@ function systemLocale() {
   }
 }
 
-let weekInfoCache = {};
+const intlResolvedOptionsCache = new Map();
+function getCachedIntResolvedOptions(locString) {
+  let opts = intlResolvedOptionsCache.get(locString);
+  if (opts === undefined) {
+    opts = new Intl.DateTimeFormat(locString).resolvedOptions();
+    intlResolvedOptionsCache.set(locString, opts);
+  }
+  return opts;
+}
+
+const weekInfoCache = new Map();
 function getCachedWeekInfo(locString) {
-  let data = weekInfoCache[locString];
+  let data = weekInfoCache.get(locString);
   if (!data) {
     const locale = new Intl.Locale(locString);
     // browsers currently implement this as a property, but spec says it should be a getter function
     data = "getWeekInfo" in locale ? locale.getWeekInfo() : locale.weekInfo;
-    weekInfoCache[locString] = data;
+    // minimalDays was removed from WeekInfo: https://github.com/tc39/proposal-intl-locale-info/issues/86
+    if (!("minimalDays" in data)) {
+      data = { ...fallbackWeekSettings, ...data };
+    }
+    weekInfoCache.set(locString, data);
   }
   return data;
 }
@@ -4983,7 +5547,7 @@ function supportsFastNumbers(loc) {
       loc.numberingSystem === "latn" ||
       !loc.locale ||
       loc.locale.startsWith("en") ||
-      new Intl.DateTimeFormat(loc.intl).resolvedOptions().numberingSystem === "latn"
+      getCachedIntResolvedOptions(loc.locale).numberingSystem === "latn"
     );
   }
 }
@@ -5142,7 +5706,6 @@ const fallbackWeekSettings = {
 /**
  * @private
  */
-
 class Locale {
   static fromOpts(opts) {
     return Locale.create(
@@ -5166,9 +5729,11 @@ class Locale {
 
   static resetCache() {
     sysLocaleCache = null;
-    intlDTCache = {};
-    intlNumCache = {};
-    intlRelCache = {};
+    intlDTCache.clear();
+    intlNumCache.clear();
+    intlRelCache.clear();
+    intlResolvedOptionsCache.clear();
+    weekInfoCache.clear();
   }
 
   static fromObject({ locale, numberingSystem, outputCalendar, weekSettings } = {}) {
@@ -5233,10 +5798,18 @@ class Locale {
 
   months(length, format = false) {
     return listStuff(this, length, months, () => {
+      // Workaround for "ja" locale: formatToParts does not label all parts of the month
+      // as "month" and for this locale there is no difference between "format" and "non-format".
+      // As such, just use format() instead of formatToParts() and take the whole string
+      const monthSpecialCase = this.intl === "ja" || this.intl.startsWith("ja-");
+      format &= !monthSpecialCase;
       const intl = format ? { month: length, day: "numeric" } : { month: length },
         formatStr = format ? "format" : "standalone";
       if (!this.monthsCache[formatStr][length]) {
-        this.monthsCache[formatStr][length] = mapMonths((dt) => this.extract(dt, intl, "month"));
+        const mapper = !monthSpecialCase
+          ? (dt) => this.extract(dt, intl, "month")
+          : (dt) => this.dtFormatter(dt, intl).format();
+        this.monthsCache[formatStr][length] = mapMonths(mapper);
       }
       return this.monthsCache[formatStr][length];
     });
@@ -5322,7 +5895,7 @@ class Locale {
     return (
       this.locale === "en" ||
       this.locale.toLowerCase() === "en-us" ||
-      new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us")
+      getCachedIntResolvedOptions(this.intl).locale.startsWith("en-us")
     );
   }
 
@@ -5661,22 +6234,26 @@ function parseDigits(str) {
 }
 
 // cache of {numberingSystem: {append: regex}}
-let digitRegexCache = {};
+const digitRegexCache = new Map();
 function resetDigitRegexCache() {
-  digitRegexCache = {};
+  digitRegexCache.clear();
 }
 
 function digitRegex({ numberingSystem }, append = "") {
   const ns = numberingSystem || "latn";
 
-  if (!digitRegexCache[ns]) {
-    digitRegexCache[ns] = {};
+  let appendCache = digitRegexCache.get(ns);
+  if (appendCache === undefined) {
+    appendCache = new Map();
+    digitRegexCache.set(ns, appendCache);
   }
-  if (!digitRegexCache[ns][append]) {
-    digitRegexCache[ns][append] = new RegExp(`${numberingSystems[ns]}${append}`);
+  let regex = appendCache.get(append);
+  if (regex === undefined) {
+    regex = new RegExp(`${numberingSystems[ns]}${append}`);
+    appendCache.set(append, regex);
   }
 
-  return digitRegexCache[ns][append];
+  return regex;
 }
 
 let now = () => Date.now(),
@@ -6218,10 +6795,24 @@ function parseMillis(fraction) {
   }
 }
 
-function roundTo(number, digits, towardZero = false) {
-  const factor = 10 ** digits,
-    rounder = towardZero ? Math.trunc : Math.round;
-  return rounder(number * factor) / factor;
+function roundTo(number, digits, rounding = "round") {
+  const factor = 10 ** digits;
+  switch (rounding) {
+    case "expand":
+      return number > 0
+        ? Math.ceil(number * factor) / factor
+        : Math.floor(number * factor) / factor;
+    case "trunc":
+      return Math.trunc(number * factor) / factor;
+    case "round":
+      return Math.round(number * factor) / factor;
+    case "floor":
+      return Math.floor(number * factor) / factor;
+    case "ceil":
+      return Math.ceil(number * factor) / factor;
+    default:
+      throw new RangeError(`Value rounding ${rounding} is out of range`);
+  }
 }
 
 // DATE BASICS
@@ -6329,7 +6920,7 @@ function signedOffset(offHourStr, offMinuteStr) {
 
 function asNumber(value) {
   const numericValue = Number(value);
-  if (typeof value === "boolean" || value === "" || Number.isNaN(numericValue))
+  if (typeof value === "boolean" || value === "" || !Number.isFinite(numericValue))
     throw new InvalidArgumentError(`Invalid unit value ${value}`);
   return numericValue;
 }
@@ -6588,8 +7179,12 @@ class Formatter {
     for (let i = 0; i < fmt.length; i++) {
       const c = fmt.charAt(i);
       if (c === "'") {
-        if (currentFull.length > 0) {
-          splits.push({ literal: bracketed || /^\s+$/.test(currentFull), val: currentFull });
+        // turn '' into a literal signal quote instead of just skipping the empty literal
+        if (currentFull.length > 0 || bracketed) {
+          splits.push({
+            literal: bracketed || /^\s+$/.test(currentFull),
+            val: currentFull === "" ? "'" : currentFull,
+          });
         }
         current = null;
         currentFull = "";
@@ -6653,7 +7248,7 @@ class Formatter {
     return this.dtFormatter(dt, opts).resolvedOptions();
   }
 
-  num(n, p = 0) {
+  num(n, p = 0, signDisplay = undefined) {
     // we get some perf out of doing this here, annoyingly
     if (this.opts.forceSimple) {
       return padStart(n, p);
@@ -6664,6 +7259,9 @@ class Formatter {
     if (p > 0) {
       opts.padTo = p;
     }
+    if (signDisplay) {
+      opts.signDisplay = signDisplay;
+    }
 
     return this.loc.numberFormatter(opts).format(n);
   }
@@ -6899,32 +7497,44 @@ class Formatter {
   }
 
   formatDurationFromString(dur, fmt) {
+    const invertLargest = this.opts.signMode === "negativeLargestOnly" ? -1 : 1;
     const tokenToField = (token) => {
         switch (token[0]) {
           case "S":
-            return "millisecond";
+            return "milliseconds";
           case "s":
-            return "second";
+            return "seconds";
           case "m":
-            return "minute";
+            return "minutes";
           case "h":
-            return "hour";
+            return "hours";
           case "d":
-            return "day";
+            return "days";
           case "w":
-            return "week";
+            return "weeks";
           case "M":
-            return "month";
+            return "months";
           case "y":
-            return "year";
+            return "years";
           default:
             return null;
         }
       },
-      tokenToString = (lildur) => (token) => {
+      tokenToString = (lildur, info) => (token) => {
         const mapped = tokenToField(token);
         if (mapped) {
-          return this.num(lildur.get(mapped), token.length);
+          const inversionFactor =
+            info.isNegativeDuration && mapped !== info.largestUnit ? invertLargest : 1;
+          let signDisplay;
+          if (this.opts.signMode === "negativeLargestOnly" && mapped !== info.largestUnit) {
+            signDisplay = "never";
+          } else if (this.opts.signMode === "all") {
+            signDisplay = "always";
+          } else {
+            // "auto" and "negative" are the same, but "auto" has better support
+            signDisplay = "auto";
+          }
+          return this.num(lildur.get(mapped) * inversionFactor, token.length, signDisplay);
         } else {
           return token;
         }
@@ -6934,8 +7544,14 @@ class Formatter {
         (found, { literal, val }) => (literal ? found : found.concat(val)),
         []
       ),
-      collapsed = dur.shiftTo(...realTokens.map(tokenToField).filter((t) => t));
-    return stringifyTokens(tokens, tokenToString(collapsed));
+      collapsed = dur.shiftTo(...realTokens.map(tokenToField).filter((t) => t)),
+      durationInfo = {
+        isNegativeDuration: collapsed < 0,
+        // this relies on "collapsed" being based on "shiftTo", which builds up the object
+        // in order
+        largestUnit: Object.keys(collapsed.values)[0],
+      };
+    return stringifyTokens(tokens, tokenToString(collapsed, durationInfo));
   }
 }
 
@@ -6996,11 +7612,11 @@ function simpleParse(...keys) {
 }
 
 // ISO and SQL parsing
-const offsetRegex = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/;
+const offsetRegex = /(?:([Zz])|([+-]\d\d)(?::?(\d\d))?)/;
 const isoExtendedZone = `(?:${offsetRegex.source}?(?:\\[(${ianaRegex.source})\\])?)?`;
 const isoTimeBaseRegex = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/;
 const isoTimeRegex = RegExp(`${isoTimeBaseRegex.source}${isoExtendedZone}`);
-const isoTimeExtensionRegex = RegExp(`(?:T${isoTimeRegex.source})?`);
+const isoTimeExtensionRegex = RegExp(`(?:[Tt]${isoTimeRegex.source})?`);
 const isoYmdRegex = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/;
 const isoWeekRegex = /(\d{4})-?W(\d\d)(?:-?(\d))?/;
 const isoOrdinalRegex = /(\d{4})-?(\d{3})/;
@@ -7715,9 +8331,13 @@ let Duration$1 = class Duration {
    * @param {string} fmt - the format string
    * @param {Object} opts - options
    * @param {boolean} [opts.floor=true] - floor numerical values
+   * @param {'negative'|'all'|'negativeLargestOnly'} [opts.signMode=negative] - How to handle signs
    * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("y d s") //=> "1 6 2"
    * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("yy dd sss") //=> "01 06 002"
    * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("M S") //=> "12 518402000"
+   * @example Duration.fromObject({ days: 6, seconds: 2 }).toFormat("d s", { signMode: "all" }) //=> "+6 +2"
+   * @example Duration.fromObject({ days: -6, seconds: -2 }).toFormat("d s", { signMode: "all" }) //=> "-6 -2"
+   * @example Duration.fromObject({ days: -6, seconds: -2 }).toFormat("d s", { signMode: "negativeLargestOnly" }) //=> "-6 2"
    * @return {string}
    */
   toFormat(fmt, opts = {}) {
@@ -7737,21 +8357,25 @@ let Duration$1 = class Duration {
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
    * @param {Object} opts - Formatting options. Accepts the same keys as the options parameter of the native `Intl.NumberFormat` constructor, as well as `listStyle`.
    * @param {string} [opts.listStyle='narrow'] - How to format the merged list. Corresponds to the `style` property of the options parameter of the native `Intl.ListFormat` constructor.
+   * @param {boolean} [opts.showZeros=true] - Show all units previously used by the duration even if they are zero
    * @example
    * ```js
-   * var dur = Duration.fromObject({ days: 1, hours: 5, minutes: 6 })
-   * dur.toHuman() //=> '1 day, 5 hours, 6 minutes'
-   * dur.toHuman({ listStyle: "long" }) //=> '1 day, 5 hours, and 6 minutes'
-   * dur.toHuman({ unitDisplay: "short" }) //=> '1 day, 5 hr, 6 min'
+   * var dur = Duration.fromObject({ months: 1, weeks: 0, hours: 5, minutes: 6 })
+   * dur.toHuman() //=> '1 month, 0 weeks, 5 hours, 6 minutes'
+   * dur.toHuman({ listStyle: "long" }) //=> '1 month, 0 weeks, 5 hours, and 6 minutes'
+   * dur.toHuman({ unitDisplay: "short" }) //=> '1 mth, 0 wks, 5 hr, 6 min'
+   * dur.toHuman({ showZeros: false }) //=> '1 month, 5 hours, 6 minutes'
    * ```
    */
   toHuman(opts = {}) {
     if (!this.isValid) return INVALID$2;
 
+    const showZeros = opts.showZeros !== false;
+
     const l = orderedUnits$1
       .map((unit) => {
         const val = this.values[unit];
-        if (isUndefined(val)) {
+        if (isUndefined(val) || (val === 0 && !showZeros)) {
           return null;
         }
         return this.loc
@@ -8111,6 +8735,17 @@ let Duration$1 = class Duration {
     return clone$1(this, { values: negated }, true);
   }
 
+  /**
+   * Removes all units with values equal to 0 from this Duration.
+   * @example Duration.fromObject({ years: 2, days: 0, hours: 0, minutes: 0 }).removeZeros().toObject() //=> { years: 2 }
+   * @return {Duration}
+   */
+  removeZeros() {
+    if (!this.isValid) return this;
+    const vals = removeZeroes(this.values);
+    return clone$1(this, { values: vals }, true);
+  }
+
   /**
    * Get the years.
    * @type {number}
@@ -8421,7 +9056,8 @@ class Interval {
   }
 
   /**
-   * Returns the end of the Interval
+   * Returns the end of the Interval. This is the first instant which is not part of the interval
+   * (Interval is half-open).
    * @type {DateTime}
    */
   get end() {
@@ -8429,8 +9065,16 @@ class Interval {
   }
 
   /**
-   * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.
-   * @type {boolean}
+   * Returns the last DateTime included in the interval (since end is not part of the interval)
+   * @type {DateTime}
+   */
+  get lastDateTime() {
+    return this.isValid ? (this.e ? this.e.minus(1) : null) : null;
+  }
+
+  /**
+   * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.
+   * @type {boolean}
    */
   get isValid() {
     return this.invalidReason === null;
@@ -8692,8 +9336,11 @@ class Interval {
   }
 
   /**
-   * Merge an array of Intervals into a equivalent minimal set of Intervals.
+   * Merge an array of Intervals into an equivalent minimal set of Intervals.
    * Combines overlapping and adjacent Intervals.
+   * The resulting array will contain the Intervals in ascending order, that is, starting with the earliest Interval
+   * and ending with the latest.
+   *
    * @param {Array} intervals
    * @return {Array}
    */
@@ -9841,21 +10488,22 @@ function toTechFormat(dt, format, allowZ = true) {
     : null;
 }
 
-function toISODate(o, extended) {
+function toISODate(o, extended, precision) {
   const longFormat = o.c.year > 9999 || o.c.year < 0;
   let c = "";
   if (longFormat && o.c.year >= 0) c += "+";
   c += padStart(o.c.year, longFormat ? 6 : 4);
-
+  if (precision === "year") return c;
   if (extended) {
     c += "-";
     c += padStart(o.c.month);
+    if (precision === "month") return c;
     c += "-";
-    c += padStart(o.c.day);
   } else {
     c += padStart(o.c.month);
-    c += padStart(o.c.day);
+    if (precision === "month") return c;
   }
+  c += padStart(o.c.day);
   return c;
 }
 
@@ -9865,26 +10513,39 @@ function toISOTime(
   suppressSeconds,
   suppressMilliseconds,
   includeOffset,
-  extendedZone
+  extendedZone,
+  precision
 ) {
-  let c = padStart(o.c.hour);
-  if (extended) {
-    c += ":";
-    c += padStart(o.c.minute);
-    if (o.c.millisecond !== 0 || o.c.second !== 0 || !suppressSeconds) {
-      c += ":";
-    }
-  } else {
-    c += padStart(o.c.minute);
-  }
-
-  if (o.c.millisecond !== 0 || o.c.second !== 0 || !suppressSeconds) {
-    c += padStart(o.c.second);
-
-    if (o.c.millisecond !== 0 || !suppressMilliseconds) {
-      c += ".";
-      c += padStart(o.c.millisecond, 3);
-    }
+  let showSeconds = !suppressSeconds || o.c.millisecond !== 0 || o.c.second !== 0,
+    c = "";
+  switch (precision) {
+    case "day":
+    case "month":
+    case "year":
+      break;
+    default:
+      c += padStart(o.c.hour);
+      if (precision === "hour") break;
+      if (extended) {
+        c += ":";
+        c += padStart(o.c.minute);
+        if (precision === "minute") break;
+        if (showSeconds) {
+          c += ":";
+          c += padStart(o.c.second);
+        }
+      } else {
+        c += padStart(o.c.minute);
+        if (precision === "minute") break;
+        if (showSeconds) {
+          c += padStart(o.c.second);
+        }
+      }
+      if (precision === "second") break;
+      if (showSeconds && (!suppressMilliseconds || o.c.millisecond !== 0)) {
+        c += ".";
+        c += padStart(o.c.millisecond, 3);
+      }
   }
 
   if (includeOffset) {
@@ -10016,15 +10677,27 @@ function normalizeUnitWithLocalWeeks(unit) {
 // This is safe for quickDT (used by local() and utc()) because we don't fill in
 // higher-order units from tsNow (as we do in fromObject, this requires that
 // offset is calculated from tsNow).
+/**
+ * @param {Zone} zone
+ * @return {number}
+ */
 function guessOffsetForZone(zone) {
-  if (!zoneOffsetGuessCache[zone]) {
-    if (zoneOffsetTs === undefined) {
-      zoneOffsetTs = Settings.now();
-    }
+  if (zoneOffsetTs === undefined) {
+    zoneOffsetTs = Settings.now();
+  }
 
-    zoneOffsetGuessCache[zone] = zone.offset(zoneOffsetTs);
+  // Do not cache anything but IANA zones, because it is not safe to do so.
+  // Guessing an offset which is not present in the zone can cause wrong results from fixOffset
+  if (zone.type !== "iana") {
+    return zone.offset(zoneOffsetTs);
+  }
+  const zoneName = zone.name;
+  let offsetGuess = zoneOffsetGuessCache.get(zoneName);
+  if (offsetGuess === undefined) {
+    offsetGuess = zone.offset(zoneOffsetTs);
+    zoneOffsetGuessCache.set(zoneName, offsetGuess);
   }
-  return zoneOffsetGuessCache[zone];
+  return offsetGuess;
 }
 
 // this is a dumbed down version of fromObject() that runs about 60% faster
@@ -10064,8 +10737,9 @@ function quickDT(obj, opts) {
 
 function diffRelative(start, end, opts) {
   const round = isUndefined(opts.round) ? true : opts.round,
+    rounding = isUndefined(opts.rounding) ? "trunc" : opts.rounding,
     format = (c, unit) => {
-      c = roundTo(c, round || opts.calendary ? 0 : 2, true);
+      c = roundTo(c, round || opts.calendary ? 0 : 2, opts.calendary ? "round" : rounding);
       const formatter = end.loc.clone(opts).relFormatter(opts);
       return formatter.format(c, unit);
     },
@@ -10114,7 +10788,7 @@ let zoneOffsetTs;
  * This optimizes quickDT via guessOffsetForZone to avoid repeated calls of
  * zone.offset().
  */
-let zoneOffsetGuessCache = {};
+const zoneOffsetGuessCache = new Map();
 
 /**
  * A DateTime is an immutable data structure representing a specific date and time and accompanying methods. It contains class and instance methods for creating, parsing, interrogating, transforming, and formatting them.
@@ -10318,7 +10992,7 @@ class DateTime {
       throw new InvalidArgumentError(
         `fromMillis requires a numerical input, but received a ${typeof milliseconds} with value ${milliseconds}`
       );
-    } else if (milliseconds < -864e13 || milliseconds > MAX_DATE) {
+    } else if (milliseconds < -MAX_DATE || milliseconds > MAX_DATE) {
       // this isn't perfect because we can still end up out of range because of additional shifting, but it's a start
       return DateTime.invalid("Timestamp out of range");
     } else {
@@ -10679,7 +11353,7 @@ class DateTime {
 
   static resetCache() {
     zoneOffsetTs = undefined;
-    zoneOffsetGuessCache = {};
+    zoneOffsetGuessCache.clear();
   }
 
   // INFO
@@ -11444,11 +12118,14 @@ class DateTime {
    * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
    * @param {boolean} [opts.extendedZone=false] - add the time zone format extension
    * @param {string} [opts.format='extended'] - choose between the basic and extended format
+   * @param {string} [opts.precision='milliseconds'] - truncate output to desired presicion: 'years', 'months', 'days', 'hours', 'minutes', 'seconds' or 'milliseconds'. When precision and suppressSeconds or suppressMilliseconds are used together, precision sets the maximum unit shown in the output, however seconds or milliseconds will still be suppressed if they are 0.
    * @example DateTime.utc(1983, 5, 25).toISO() //=> '1982-05-25T00:00:00.000Z'
    * @example DateTime.now().toISO() //=> '2017-04-22T20:47:05.335-04:00'
    * @example DateTime.now().toISO({ includeOffset: false }) //=> '2017-04-22T20:47:05.335'
    * @example DateTime.now().toISO({ format: 'basic' }) //=> '20170422T204705.335-0400'
-   * @return {string}
+   * @example DateTime.now().toISO({ precision: 'day' }) //=> '2017-04-22Z'
+   * @example DateTime.now().toISO({ precision: 'minute' }) //=> '2017-04-22T20:47Z'
+   * @return {string|null}
    */
   toISO({
     format = "extended",
@@ -11456,16 +12133,26 @@ class DateTime {
     suppressMilliseconds = false,
     includeOffset = true,
     extendedZone = false,
+    precision = "milliseconds",
   } = {}) {
     if (!this.isValid) {
       return null;
     }
 
+    precision = normalizeUnit(precision);
     const ext = format === "extended";
 
-    let c = toISODate(this, ext);
-    c += "T";
-    c += toISOTime(this, ext, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone);
+    let c = toISODate(this, ext, precision);
+    if (orderedUnits.indexOf(precision) >= 3) c += "T";
+    c += toISOTime(
+      this,
+      ext,
+      suppressSeconds,
+      suppressMilliseconds,
+      includeOffset,
+      extendedZone,
+      precision
+    );
     return c;
   }
 
@@ -11473,16 +12160,17 @@ class DateTime {
    * Returns an ISO 8601-compliant string representation of this DateTime's date component
    * @param {Object} opts - options
    * @param {string} [opts.format='extended'] - choose between the basic and extended format
+   * @param {string} [opts.precision='day'] - truncate output to desired precision: 'years', 'months', or 'days'.
    * @example DateTime.utc(1982, 5, 25).toISODate() //=> '1982-05-25'
    * @example DateTime.utc(1982, 5, 25).toISODate({ format: 'basic' }) //=> '19820525'
-   * @return {string}
+   * @example DateTime.utc(1982, 5, 25).toISODate({ precision: 'month' }) //=> '1982-05'
+   * @return {string|null}
    */
-  toISODate({ format = "extended" } = {}) {
+  toISODate({ format = "extended", precision = "day" } = {}) {
     if (!this.isValid) {
       return null;
     }
-
-    return toISODate(this, format === "extended");
+    return toISODate(this, format === "extended", normalizeUnit(precision));
   }
 
   /**
@@ -11503,10 +12191,12 @@ class DateTime {
    * @param {boolean} [opts.extendedZone=true] - add the time zone format extension
    * @param {boolean} [opts.includePrefix=false] - include the `T` prefix
    * @param {string} [opts.format='extended'] - choose between the basic and extended format
+   * @param {string} [opts.precision='milliseconds'] - truncate output to desired presicion: 'hours', 'minutes', 'seconds' or 'milliseconds'. When precision and suppressSeconds or suppressMilliseconds are used together, precision sets the maximum unit shown in the output, however seconds or milliseconds will still be suppressed if they are 0.
    * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime() //=> '07:34:19.361Z'
    * @example DateTime.utc().set({ hour: 7, minute: 34, seconds: 0, milliseconds: 0 }).toISOTime({ suppressSeconds: true }) //=> '07:34Z'
    * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ format: 'basic' }) //=> '073419.361Z'
    * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ includePrefix: true }) //=> 'T07:34:19.361Z'
+   * @example DateTime.utc().set({ hour: 7, minute: 34, second: 56 }).toISOTime({ precision: 'minute' }) //=> '07:34Z'
    * @return {string}
    */
   toISOTime({
@@ -11516,12 +12206,14 @@ class DateTime {
     includePrefix = false,
     extendedZone = false,
     format = "extended",
+    precision = "milliseconds",
   } = {}) {
     if (!this.isValid) {
       return null;
     }
 
-    let c = includePrefix ? "T" : "";
+    precision = normalizeUnit(precision);
+    let c = includePrefix && orderedUnits.indexOf(precision) >= 3 ? "T" : "";
     return (
       c +
       toISOTime(
@@ -11530,7 +12222,8 @@ class DateTime {
         suppressSeconds,
         suppressMilliseconds,
         includeOffset,
-        extendedZone
+        extendedZone,
+        precision
       )
     );
   }
@@ -11560,7 +12253,7 @@ class DateTime {
   /**
    * Returns a string representation of this DateTime appropriate for use in SQL Date
    * @example DateTime.utc(2014, 7, 13).toSQLDate() //=> '2014-07-13'
-   * @return {string}
+   * @return {string|null}
    */
   toSQLDate() {
     if (!this.isValid) {
@@ -11655,7 +12348,7 @@ class DateTime {
   }
 
   /**
-   * Returns the epoch seconds of this DateTime.
+   * Returns the epoch seconds (including milliseconds in the fractional part) of this DateTime.
    * @return {number}
    */
   toSeconds() {
@@ -11762,7 +12455,7 @@ class DateTime {
   /**
    * Return an Interval spanning between this DateTime and another DateTime
    * @param {DateTime} otherDateTime - the other end point of the Interval
-   * @return {Interval}
+   * @return {Interval|DateTime}
    */
   until(otherDateTime) {
     return this.isValid ? Interval.fromDateTimes(this, otherDateTime) : this;
@@ -11808,12 +12501,13 @@ class DateTime {
 
   /**
    * Returns a string representation of a this time relative to now, such as "in two days". Can only internationalize if your
-   * platform supports Intl.RelativeTimeFormat. Rounds down by default.
+   * platform supports Intl.RelativeTimeFormat. Rounds towards zero by default.
    * @param {Object} options - options that affect the output
    * @param {DateTime} [options.base=DateTime.now()] - the DateTime to use as the basis to which this time is compared. Defaults to now.
    * @param {string} [options.style="long"] - the style of units, must be "long", "short", or "narrow"
    * @param {string|string[]} options.unit - use a specific unit or array of units; if omitted, or an array, the method will pick the best unit. Use an array or one of "years", "quarters", "months", "weeks", "days", "hours", "minutes", or "seconds"
    * @param {boolean} [options.round=true] - whether to round the numbers in the output.
+   * @param {string} [options.rounding="trunc"] - rounding method to use when rounding the numbers in the output. Can be "trunc" (toward zero), "expand" (away from zero), "round", "floor", or "ceil".
    * @param {number} [options.padding=0] - padding in milliseconds. This allows you to round up the result if it fits inside the threshold. Don't use in combination with {round: false} because the decimal output will include the padding.
    * @param {string} options.locale - override the locale of this DateTime
    * @param {string} options.numberingSystem - override the numberingSystem of this DateTime. The Intl system may choose not to honor this
@@ -14201,7 +14895,7 @@ class BinaryReader {
                     // ignore
                 }
                 break;
-            // @ts-expect-error TS7029: Fallthrough case in switch
+            // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
             case WireType.Bit64:
                 this.pos += 4;
             case WireType.Bit32:
@@ -14482,7 +15176,6 @@ function around(index, lng, lat, maxResults = Infinity, maxDistance = Infinity,
         left: 0, // left index in the kd-tree array
         right: index.ids.length - 1, // right index
         axis: 0, // 0 for longitude axis and 1 for latitude axis
-        dist: 0, // will hold the lower bound of children's distances to the query point
         minLng: -180, // bounding box of the node
         minLat: -90,
         maxLng: 180,
@@ -14950,7 +15643,7 @@ function sqDist(ax, ay, bx, by) {
     return dx * dx + dy * dy;
 }
 
-const xt="ENTRIES",B="KEYS",G="VALUES",g="";class V{set;_type;_path;constructor(e,n){const o=e._tree,s=Array.from(o.keys());this.set=e,this._type=n,this._path=s.length>0?[{node:o,keys:s}]:[];}next(){const e=this.dive();return this.backtrack(),e}dive(){if(this._path.length===0)return {done:true,value:undefined};const{node:e,keys:n}=z(this._path);if(z(n)===g)return {done:false,value:this.result()};const o=e.get(z(n));return this._path.push({node:o,keys:Array.from(o.keys())}),this.dive()}backtrack(){if(this._path.length===0)return;const e=z(this._path).keys;e.pop(),!(e.length>0)&&(this._path.pop(),this.backtrack());}key(){return this.set._prefix+this._path.map(({keys:e})=>z(e)).filter(e=>e!==g).join("")}value(){return z(this._path).node.get(g)}result(){switch(this._type){case G:return this.value();case B:return this.key();default:return [this.key(),this.value()]}}[Symbol.iterator](){return this}}const z=t=>t[t.length-1],zt=(t,e,n)=>{const o=new Map;if(typeof e!="string")return o;const s=e.length+1,r=s+n,i=new Uint8Array(r*s).fill(n+1);for(let c=0;c<s;++c)i[c]=c;for(let c=1;c<r;++c)i[c*s]=c;return K(t,e,n,o,i,1,s,""),o},K=(t,e,n,o,s,r,i,c)=>{const u=r*i;t:for(const d of t.keys())if(d===g){const a=s[u-1];a<=n&&o.set(c,[t.get(d),a]);}else {let a=r;for(let h=0;h<d.length;++h,++a){const f=d[h],_=i*a,p=_-i;let l=s[_];const m=Math.max(0,a-n-1),y=Math.min(i-1,a+n);for(let w=m;w<y;++w){const C=f!==e[w],O=s[p+w]+ +C,b=s[p+w+1]+1,x=s[_+w]+1,S=s[_+w+1]=Math.min(O,b,x);S<l&&(l=S);}if(l>n)continue t}K(t.get(d),e,n,o,s,a,i,c+d);}};class I{_tree;_prefix;_size=undefined;constructor(e=new Map,n=""){this._tree=e,this._prefix=n;}atPrefix(e){if(!e.startsWith(this._prefix))throw new Error("Mismatched prefix");const[n,o]=v(this._tree,e.slice(this._prefix.length));if(n===undefined){const[s,r]=L(o);for(const i of s.keys())if(i!==g&&i.startsWith(r)){const c=new Map;return c.set(i.slice(r.length),s.get(i)),new I(c,e)}}return new I(n,e)}clear(){this._size=undefined,this._tree.clear();}delete(e){return this._size=undefined,St(this._tree,e)}entries(){return new V(this,xt)}forEach(e){for(const[n,o]of this)e(n,o,this);}fuzzyGet(e,n){return zt(this._tree,e,n)}get(e){const n=T(this._tree,e);return n!==undefined?n.get(g):undefined}has(e){return T(this._tree,e)?.has(g)??false}keys(){return new V(this,B)}set(e,n){if(typeof e!="string")throw new Error("key must be a string");return this._size=undefined,M(this._tree,e).set(g,n),this}get size(){if(this._size)return this._size;this._size=0;const e=this.entries();for(;!e.next().done;)this._size+=1;return this._size}update(e,n){if(typeof e!="string")throw new Error("key must be a string");this._size=undefined;const o=M(this._tree,e);return o.set(g,n(o.get(g))),this}fetch(e,n){if(typeof e!="string")throw new Error("key must be a string");this._size=undefined;const o=M(this._tree,e);let s=o.get(g);return s===undefined&&o.set(g,s=n()),s}values(){return new V(this,G)}[Symbol.iterator](){return this.entries()}static from(e){const n=new I;for(const[o,s]of e)n.set(o,s);return n}static fromObject(e){return I.from(Object.entries(e))}}const v=(t,e,n=[])=>{if(e.length===0||t==null)return [t,n];for(const o of t.keys())if(o!==g&&e.startsWith(o))return n.push([t,o]),v(t.get(o),e.slice(o.length),n);return n.push([t,e]),v(undefined,"",n)},T=(t,e)=>{if(e.length===0||!t)return t;for(const n of t.keys())if(n!==g&&e.startsWith(n))return T(t.get(n),e.slice(n.length))},M=(t,e)=>{const n=e.length;t:for(let o=0;t&&o<n;){for(const r of t.keys())if(r!==g&&e[o]===r[0]){const i=Math.min(n-o,r.length);let c=1;for(;c<i&&e[o+c]===r[c];)++c;const u=t.get(r);if(c===r.length)t=u;else {const d=new Map;d.set(r.slice(c),u),t.set(e.slice(o,o+c),d),t.delete(r),t=d;}o+=c;continue t}const s=new Map;return t.set(e.slice(o),s),s}return t},St=(t,e)=>{const[n,o]=v(t,e);if(n!==undefined){if(n.delete(g),n.size===0)Q(o);else if(n.size===1){const[s,r]=n.entries().next().value;Y(o,s,r);}}},Q=t=>{if(t.length===0)return;const[e,n]=L(t);if(e.delete(n),e.size===0)Q(t.slice(0,-1));else if(e.size===1){const[o,s]=e.entries().next().value;o!==g&&Y(t.slice(0,-1),o,s);}},Y=(t,e,n)=>{if(t.length===0)return;const[o,s]=L(t);o.set(s+e,n),o.delete(s);},L=t=>t[t.length-1],Z=(t,e)=>t._idToShortId.has(e),vt=/[\n\r\p{Z}\p{P}]+/u,D="or",H="and",Ft="and_not",kt=(t,e)=>{t.includes(e)||t.push(e);},tt=(t,e)=>{for(const n of e)t.includes(n)||t.push(n);},et=({score:t},{score:e})=>e-t,nt=()=>new Map,E=(t,e)=>Object.prototype.hasOwnProperty.call(t,e)?t[e]:undefined,ot={[D]:(t,e)=>{for(const n of e.keys()){const o=t.get(n);if(o==null)t.set(n,e.get(n));else {const{score:s,terms:r,match:i}=e.get(n);o.score=o.score+s,o.match=Object.assign(o.match,i),tt(o.terms,r);}}return t},[H]:(t,e)=>{const n=new Map;for(const o of e.keys()){const s=t.get(o);if(s==null)continue;const{score:r,terms:i,match:c}=e.get(o);tt(s.terms,i),n.set(o,{score:s.score+r,terms:s.terms,match:Object.assign(s.match,c)});}return n},[Ft]:(t,e)=>{for(const n of e.keys())t.delete(n);return t}},Ct=(t,e,n,o,s,r)=>{const{k:i,b:c,d:u}=r;return Math.log(1+(n-e+.5)/(e+.5))*(u+t*(i+1)/(t+i*(1-c+c*o/s)))},Ot=t=>(e,n,o)=>({term:e,fuzzy:typeof t.fuzzy=="function"?t.fuzzy(e,n,o):t.fuzzy??false,prefix:typeof t.prefix=="function"?t.prefix(e,n,o):t.prefix===true,termBoost:typeof t.boostTerm=="function"?t.boostTerm(e,n,o):1}),st=(t,e,n,o)=>{for(const s of Object.keys(t._fieldIds))if(t._fieldIds[s]===n){t._options.logger("warn",`SlimSearch: document with ID ${t._documentIds.get(e)} has changed before removal: term "${o}" was not present in field "${s}". Removing a document after it has changed can corrupt the index!`,"version_conflict");return}},it=(t,e,n,o)=>{const s=t._index.fetch(o,nt);let r=s.get(e);if(r==null)r=new Map,r.set(n,1),s.set(e,r);else {const i=r.get(n);r.set(n,(i??0)+1);}},A=(t,e,n,o)=>{if(!t._index.has(o)){st(t,n,e,o);return}const s=t._index.fetch(o,nt),r=s.get(e),i=r?.get(n);!r||typeof i>"u"?st(t,n,e,o):i<=1?r.size<=1?s.delete(e):r.delete(n):r.set(n,i-1),t._index.get(o).size===0&&t._index.delete(o);},Vt=(t,e,n,o,s)=>{let r=t._fieldLength.get(e);r==null&&t._fieldLength.set(e,r=[]),r[n]=s;const i=(t._avgFieldLength[n]||0)*o+s;t._avgFieldLength[n]=i/(o+1);},Tt=(t,e)=>{const n=t._nextId;return t._idToShortId.set(e,n),t._documentIds.set(n,e),t._documentCount+=1,t._nextId+=1,n},Mt=(t,e,n)=>{const{storeFields:o,extractField:s}=t._options;if(o?.length===0)return;let r=t._storedFields.get(e);r===undefined&&t._storedFields.set(e,r={});for(const i of o){const c=s(n,i);c!=null&&(r[i]=c);}},j=(t,e)=>{const{extractField:n,tokenize:o,processTerm:s,fields:r,idField:i}=t._options,c=n(e,i);if(c==null)throw new Error(`SlimSearch: document does not have ID field "${i}"`);if(Z(t,c))throw new Error(`SlimSearch: duplicate ID ${c}`);const u=Tt(t,c);Mt(t,u,e);for(const d of r){const a=n(e,d);if(a==null)continue;const h=o(a.toString(),d),f=t._fieldIds[d],_=new Set(h).size;Vt(t,u,f,t._documentCount-1,_);for(const p of h){const l=s(p,d);if(Array.isArray(l))for(const m of l)it(t,f,u,m);else l&&it(t,f,u,l);}}},q=(t,e)=>{for(const n of e)j(t,n);},Dt={k:1.2,b:.7,d:.5},$={idField:"id",extractField:(t,e)=>t[e],tokenize:t=>t.split(vt),processTerm:t=>t.toLowerCase(),fields:undefined,searchOptions:undefined,storeFields:[],logger:(t,e)=>{console?.[t]?.(e);},autoVacuum:true},rt={combineWith:D,prefix:false,fuzzy:false,maxFuzzy:6,boost:{},weights:{fuzzy:.45,prefix:.375},bm25:Dt},Et={combineWith:H,prefix:(t,e,n)=>e===n.length-1},N={batchSize:1e3,batchWait:10},W={minDirtFactor:.1,minDirtCount:20},P={...N,...W},R=Symbol("*"),jt=(t,e)=>{const n=new Map,o={...t._options.searchOptions,...e};for(const[s,r]of t._documentIds){const i=o.boostDocument?o.boostDocument(r,"",t._storedFields.get(s)):1;n.set(s,{score:i,terms:[],match:{}});}return n},ct=(t,e=D)=>{if(t.length===0)return new Map;const n=e.toLowerCase();if(!(n in ot))throw new Error(`Invalid combination operator: ${e}`);return t.reduce(ot[n])},J=(t,e,n,o,s,r,i,c,u,d=new Map)=>{if(r==null)return d;for(const a of Object.keys(i)){const h=i[a],f=t._fieldIds[a],_=r.get(f);if(_==null)continue;let p=_.size;const l=t._avgFieldLength[f];for(const m of _.keys()){if(!t._documentIds.has(m)){A(t,f,m,n),p-=1;continue}const y=c?c(t._documentIds.get(m),n,t._storedFields.get(m)):1;if(!y)continue;const w=_.get(m),C=t._fieldLength.get(m)[f],O=Ct(w,p,t._documentCount,C,l,u),b=o*s*h*y*O,x=d.get(m);if(x){x.score+=b,kt(x.terms,e);const S=E(x.match,n);S?S.push(a):x.match[n]=[a];}else d.set(m,{score:b,terms:[e],match:{[n]:[a]}});}}return d},qt=(t,e,n)=>{const o={...t._options.searchOptions,...n},s=(o.fields??t._options.fields).reduce((l,m)=>({...l,[m]:E(o.boost,m)||1}),{}),{boostDocument:r,weights:i,maxFuzzy:c,bm25:u}=o,{fuzzy:d,prefix:a}={...rt.weights,...i},h=t._index.get(e.term),f=J(t,e.term,e.term,1,e.termBoost,h,s,r,u);let _,p;if(e.prefix&&(_=t._index.atPrefix(e.term)),e.fuzzy){const l=e.fuzzy===true?.2:e.fuzzy,m=l<1?Math.min(c,Math.round(e.term.length*l)):l;m&&(p=t._index.fuzzyGet(e.term,m));}if(_)for(const[l,m]of _){const y=l.length-e.term.length;if(!y)continue;p?.delete(l);const w=a*l.length/(l.length+.3*y);J(t,e.term,l,w,e.termBoost,m,s,r,u,f);}if(p)for(const l of p.keys()){const[m,y]=p.get(l);if(!y)continue;const w=d*l.length/(l.length+y);J(t,e.term,l,w,e.termBoost,m,s,r,u,f);}return f},ut=(t,e,n={})=>{if(e===R)return jt(t,n);if(typeof e!="string"){const a={...n,...e,queries:undefined},h=e.queries.map(f=>ut(t,f,a));return ct(h,a.combineWith)}const{tokenize:o,processTerm:s,searchOptions:r}=t._options,i={tokenize:o,processTerm:s,...r,...n},{tokenize:c,processTerm:u}=i,d=c(e).flatMap(a=>u(a)).filter(a=>!!a).map(Ot(i)).map(a=>qt(t,a,i));return ct(d,i.combineWith)},dt=(t,e,n={})=>{const{searchOptions:o}=t._options,s={...o,...n},r=ut(t,e,n),i=[];for(const[c,{score:u,terms:d,match:a}]of r){const h=d.length||1,f={id:t._documentIds.get(c),score:u*h,terms:Object.keys(a),queryTerms:d,match:a};Object.assign(f,t._storedFields.get(c)),(s.filter==null||s.filter(f))&&i.push(f);}return e===R&&s.boostDocument==null||i.sort(et),i};class Nt{_options;_index;_documentCount;_documentIds;_idToShortId;_fieldIds;_fieldLength;_avgFieldLength;_nextId;_storedFields;_dirtCount;_currentVacuum;_enqueuedVacuum;_enqueuedVacuumConditions;constructor(e){if(!e?.fields)throw new Error('SlimSearch: option "fields" must be provided');const n=e.autoVacuum==null||e.autoVacuum===true?P:e.autoVacuum;this._options={...$,...e,autoVacuum:n,searchOptions:{...rt,...e.searchOptions},autoSuggestOptions:{...Et,...e.autoSuggestOptions}},this._index=new I,this._documentCount=0,this._documentIds=new Map,this._idToShortId=new Map,this._fieldIds={},this._fieldLength=new Map,this._avgFieldLength=[],this._nextId=0,this._storedFields=new Map,this._dirtCount=0,this._currentVacuum=null,this._enqueuedVacuum=null,this._enqueuedVacuumConditions=W,this.addFields(this._options.fields);}get isVacuuming(){return this._currentVacuum!=null}get dirtCount(){return this._dirtCount}get dirtFactor(){return this._dirtCount/(1+this._documentCount+this._dirtCount)}get documentCount(){return this._documentCount}get termCount(){return this._index.size}toJSON(){const e=[];for(const[n,o]of this._index){const s={};for(const[r,i]of o)s[r]=Object.fromEntries(i);e.push([n,s]);}return {documentCount:this._documentCount,nextId:this._nextId,documentIds:Object.fromEntries(this._documentIds),fieldIds:this._fieldIds,fieldLength:Object.fromEntries(this._fieldLength),averageFieldLength:this._avgFieldLength,storedFields:Object.fromEntries(this._storedFields),dirtCount:this._dirtCount,index:e,version:2}}addFields(e){for(let n=0;n<e.length;n++)this._fieldIds[e[n]]=n;}}const lt=t=>new Nt(t);
+const xt="ENTRIES",B="KEYS",G="VALUES",g="";class V{set;_type;_path;constructor(e,n){const o=e._tree,s=Array.from(o.keys());this.set=e,this._type=n,this._path=s.length>0?[{node:o,keys:s}]:[];}next(){const e=this.dive();return this.backtrack(),e}dive(){if(this._path.length===0)return {done:true,value:void 0};const{node:e,keys:n}=z(this._path);if(z(n)===g)return {done:false,value:this.result()};const o=e.get(z(n));return this._path.push({node:o,keys:Array.from(o.keys())}),this.dive()}backtrack(){if(this._path.length===0)return;const e=z(this._path).keys;e.pop(),!(e.length>0)&&(this._path.pop(),this.backtrack());}key(){return this.set._prefix+this._path.map(({keys:e})=>z(e)).filter(e=>e!==g).join("")}value(){return z(this._path).node.get(g)}result(){switch(this._type){case G:return this.value();case B:return this.key();default:return [this.key(),this.value()]}}[Symbol.iterator](){return this}}const z=t=>t[t.length-1],zt=(t,e,n)=>{const o=new Map;if(typeof e!="string")return o;const s=e.length+1,r=s+n,i=new Uint8Array(r*s).fill(n+1);for(let c=0;c<s;++c)i[c]=c;for(let c=1;c<r;++c)i[c*s]=c;return K(t,e,n,o,i,1,s,""),o},K=(t,e,n,o,s,r,i,c)=>{const u=r*i;t:for(const d of t.keys())if(d===g){const a=s[u-1];a<=n&&o.set(c,[t.get(d),a]);}else {let a=r;for(let h=0;h<d.length;++h,++a){const f=d[h],_=i*a,p=_-i;let l=s[_];const m=Math.max(0,a-n-1),y=Math.min(i-1,a+n);for(let w=m;w<y;++w){const C=f!==e[w],O=s[p+w]+ +C,b=s[p+w+1]+1,x=s[_+w]+1,S=s[_+w+1]=Math.min(O,b,x);S<l&&(l=S);}if(l>n)continue t}K(t.get(d),e,n,o,s,a,i,c+d);}};class I{_tree;_prefix;_size=void 0;constructor(e=new Map,n=""){this._tree=e,this._prefix=n;}atPrefix(e){if(!e.startsWith(this._prefix))throw new Error("Mismatched prefix");const[n,o]=v(this._tree,e.slice(this._prefix.length));if(n===void 0){const[s,r]=L(o);for(const i of s.keys())if(i!==g&&i.startsWith(r)){const c=new Map;return c.set(i.slice(r.length),s.get(i)),new I(c,e)}}return new I(n,e)}clear(){this._size=void 0,this._tree.clear();}delete(e){return this._size=void 0,St(this._tree,e)}entries(){return new V(this,xt)}forEach(e){for(const[n,o]of this)e(n,o,this);}fuzzyGet(e,n){return zt(this._tree,e,n)}get(e){const n=T(this._tree,e);return n!==void 0?n.get(g):void 0}has(e){return T(this._tree,e)?.has(g)??false}keys(){return new V(this,B)}set(e,n){if(typeof e!="string")throw new Error("key must be a string");return this._size=void 0,M(this._tree,e).set(g,n),this}get size(){if(this._size)return this._size;this._size=0;const e=this.entries();for(;!e.next().done;)this._size+=1;return this._size}update(e,n){if(typeof e!="string")throw new Error("key must be a string");this._size=void 0;const o=M(this._tree,e);return o.set(g,n(o.get(g))),this}fetch(e,n){if(typeof e!="string")throw new Error("key must be a string");this._size=void 0;const o=M(this._tree,e);let s=o.get(g);return s===void 0&&o.set(g,s=n()),s}values(){return new V(this,G)}[Symbol.iterator](){return this.entries()}static from(e){const n=new I;for(const[o,s]of e)n.set(o,s);return n}static fromObject(e){return I.from(Object.entries(e))}}const v=(t,e,n=[])=>{if(e.length===0||t==null)return [t,n];for(const o of t.keys())if(o!==g&&e.startsWith(o))return n.push([t,o]),v(t.get(o),e.slice(o.length),n);return n.push([t,e]),v(void 0,"",n)},T=(t,e)=>{if(e.length===0||!t)return t;for(const n of t.keys())if(n!==g&&e.startsWith(n))return T(t.get(n),e.slice(n.length))},M=(t,e)=>{const n=e.length;t:for(let o=0;t&&o<n;){for(const r of t.keys())if(r!==g&&e[o]===r[0]){const i=Math.min(n-o,r.length);let c=1;for(;c<i&&e[o+c]===r[c];)++c;const u=t.get(r);if(c===r.length)t=u;else {const d=new Map;d.set(r.slice(c),u),t.set(e.slice(o,o+c),d),t.delete(r),t=d;}o+=c;continue t}const s=new Map;return t.set(e.slice(o),s),s}return t},St=(t,e)=>{const[n,o]=v(t,e);if(n!==void 0){if(n.delete(g),n.size===0)Q(o);else if(n.size===1){const[s,r]=n.entries().next().value;Y(o,s,r);}}},Q=t=>{if(t.length===0)return;const[e,n]=L(t);if(e.delete(n),e.size===0)Q(t.slice(0,-1));else if(e.size===1){const[o,s]=e.entries().next().value;o!==g&&Y(t.slice(0,-1),o,s);}},Y=(t,e,n)=>{if(t.length===0)return;const[o,s]=L(t);o.set(s+e,n),o.delete(s);},L=t=>t[t.length-1],Z=(t,e)=>t._idToShortId.has(e),vt=/[\n\r\p{Z}\p{P}]+/u,D="or",H="and",Ft="and_not",kt=(t,e)=>{t.includes(e)||t.push(e);},tt=(t,e)=>{for(const n of e)t.includes(n)||t.push(n);},et=({score:t},{score:e})=>e-t,nt=()=>new Map,E=(t,e)=>Object.prototype.hasOwnProperty.call(t,e)?t[e]:void 0,ot={[D]:(t,e)=>{for(const n of e.keys()){const o=t.get(n);if(o==null)t.set(n,e.get(n));else {const{score:s,terms:r,match:i}=e.get(n);o.score=o.score+s,o.match=Object.assign(o.match,i),tt(o.terms,r);}}return t},[H]:(t,e)=>{const n=new Map;for(const o of e.keys()){const s=t.get(o);if(s==null)continue;const{score:r,terms:i,match:c}=e.get(o);tt(s.terms,i),n.set(o,{score:s.score+r,terms:s.terms,match:Object.assign(s.match,c)});}return n},[Ft]:(t,e)=>{for(const n of e.keys())t.delete(n);return t}},Ct=(t,e,n,o,s,r)=>{const{k:i,b:c,d:u}=r;return Math.log(1+(n-e+.5)/(e+.5))*(u+t*(i+1)/(t+i*(1-c+c*o/s)))},Ot=t=>(e,n,o)=>({term:e,fuzzy:typeof t.fuzzy=="function"?t.fuzzy(e,n,o):t.fuzzy??false,prefix:typeof t.prefix=="function"?t.prefix(e,n,o):t.prefix===true,termBoost:typeof t.boostTerm=="function"?t.boostTerm(e,n,o):1}),st=(t,e,n,o)=>{for(const s of Object.keys(t._fieldIds))if(t._fieldIds[s]===n){t._options.logger("warn",`SlimSearch: document with ID ${t._documentIds.get(e)} has changed before removal: term "${o}" was not present in field "${s}". Removing a document after it has changed can corrupt the index!`,"version_conflict");return}},it=(t,e,n,o)=>{const s=t._index.fetch(o,nt);let r=s.get(e);if(r==null)r=new Map,r.set(n,1),s.set(e,r);else {const i=r.get(n);r.set(n,(i??0)+1);}},A=(t,e,n,o)=>{if(!t._index.has(o)){st(t,n,e,o);return}const s=t._index.fetch(o,nt),r=s.get(e),i=r?.get(n);!r||typeof i>"u"?st(t,n,e,o):i<=1?r.size<=1?s.delete(e):r.delete(n):r.set(n,i-1),t._index.get(o).size===0&&t._index.delete(o);},Vt=(t,e,n,o,s)=>{let r=t._fieldLength.get(e);r==null&&t._fieldLength.set(e,r=[]),r[n]=s;const i=(t._avgFieldLength[n]||0)*o+s;t._avgFieldLength[n]=i/(o+1);},Tt=(t,e)=>{const n=t._nextId;return t._idToShortId.set(e,n),t._documentIds.set(n,e),t._documentCount+=1,t._nextId+=1,n},Mt=(t,e,n)=>{const{storeFields:o,extractField:s}=t._options;if(o?.length===0)return;let r=t._storedFields.get(e);r===void 0&&t._storedFields.set(e,r={});for(const i of o){const c=s(n,i);c!=null&&(r[i]=c);}},j=(t,e)=>{const{extractField:n,tokenize:o,processTerm:s,fields:r,idField:i}=t._options,c=n(e,i);if(c==null)throw new Error(`SlimSearch: document does not have ID field "${i}"`);if(Z(t,c))throw new Error(`SlimSearch: duplicate ID ${c}`);const u=Tt(t,c);Mt(t,u,e);for(const d of r){const a=n(e,d);if(a==null)continue;const h=o(a.toString(),d),f=t._fieldIds[d],_=new Set(h).size;Vt(t,u,f,t._documentCount-1,_);for(const p of h){const l=s(p,d);if(Array.isArray(l))for(const m of l)it(t,f,u,m);else l&&it(t,f,u,l);}}},q=(t,e)=>{for(const n of e)j(t,n);},Dt={k:1.2,b:.7,d:.5},$={idField:"id",extractField:(t,e)=>t[e],tokenize:t=>t.split(vt),processTerm:t=>t.toLowerCase(),fields:void 0,searchOptions:void 0,storeFields:[],logger:(t,e)=>{console?.[t]?.(e);},autoVacuum:true},rt={combineWith:D,prefix:false,fuzzy:false,maxFuzzy:6,boost:{},weights:{fuzzy:.45,prefix:.375},bm25:Dt},Et={combineWith:H,prefix:(t,e,n)=>e===n.length-1},N={batchSize:1e3,batchWait:10},W={minDirtFactor:.1,minDirtCount:20},P={...N,...W},R=Symbol("*"),jt=(t,e)=>{const n=new Map,o={...t._options.searchOptions,...e};for(const[s,r]of t._documentIds){const i=o.boostDocument?o.boostDocument(r,"",t._storedFields.get(s)):1;n.set(s,{score:i,terms:[],match:{}});}return n},ct=(t,e=D)=>{if(t.length===0)return new Map;const n=e.toLowerCase();if(!(n in ot))throw new Error(`Invalid combination operator: ${e}`);return t.reduce(ot[n])},J=(t,e,n,o,s,r,i,c,u,d=new Map)=>{if(r==null)return d;for(const a of Object.keys(i)){const h=i[a],f=t._fieldIds[a],_=r.get(f);if(_==null)continue;let p=_.size;const l=t._avgFieldLength[f];for(const m of _.keys()){if(!t._documentIds.has(m)){A(t,f,m,n),p-=1;continue}const y=c?c(t._documentIds.get(m),n,t._storedFields.get(m)):1;if(!y)continue;const w=_.get(m),C=t._fieldLength.get(m)[f],O=Ct(w,p,t._documentCount,C,l,u),b=o*s*h*y*O,x=d.get(m);if(x){x.score+=b,kt(x.terms,e);const S=E(x.match,n);S?S.push(a):x.match[n]=[a];}else d.set(m,{score:b,terms:[e],match:{[n]:[a]}});}}return d},qt=(t,e,n)=>{const o={...t._options.searchOptions,...n},s=(o.fields??t._options.fields).reduce((l,m)=>({...l,[m]:E(o.boost,m)||1}),{}),{boostDocument:r,weights:i,maxFuzzy:c,bm25:u}=o,{fuzzy:d,prefix:a}={...rt.weights,...i},h=t._index.get(e.term),f=J(t,e.term,e.term,1,e.termBoost,h,s,r,u);let _,p;if(e.prefix&&(_=t._index.atPrefix(e.term)),e.fuzzy){const l=e.fuzzy===true?.2:e.fuzzy,m=l<1?Math.min(c,Math.round(e.term.length*l)):l;m&&(p=t._index.fuzzyGet(e.term,m));}if(_)for(const[l,m]of _){const y=l.length-e.term.length;if(!y)continue;p?.delete(l);const w=a*l.length/(l.length+.3*y);J(t,e.term,l,w,e.termBoost,m,s,r,u,f);}if(p)for(const l of p.keys()){const[m,y]=p.get(l);if(!y)continue;const w=d*l.length/(l.length+y);J(t,e.term,l,w,e.termBoost,m,s,r,u,f);}return f},ut=(t,e,n={})=>{if(e===R)return jt(t,n);if(typeof e!="string"){const a={...n,...e,queries:void 0},h=e.queries.map(f=>ut(t,f,a));return ct(h,a.combineWith)}const{tokenize:o,processTerm:s,searchOptions:r}=t._options,i={tokenize:o,processTerm:s,...r,...n},{tokenize:c,processTerm:u}=i,d=c(e).flatMap(a=>u(a)).filter(a=>!!a).map(Ot(i)).map(a=>qt(t,a,i));return ct(d,i.combineWith)},dt=(t,e,n={})=>{const{searchOptions:o}=t._options,s={...o,...n},r=ut(t,e,n),i=[];for(const[c,{score:u,terms:d,match:a}]of r){const h=d.length||1,f={id:t._documentIds.get(c),score:u*h,terms:Object.keys(a),queryTerms:d,match:a};Object.assign(f,t._storedFields.get(c)),(s.filter==null||s.filter(f))&&i.push(f);}return e===R&&s.boostDocument==null||i.sort(et),i};class Nt{_options;_index;_documentCount;_documentIds;_idToShortId;_fieldIds;_fieldLength;_avgFieldLength;_nextId;_storedFields;_dirtCount;_currentVacuum;_enqueuedVacuum;_enqueuedVacuumConditions;constructor(e){if(!e?.fields)throw new Error('SlimSearch: option "fields" must be provided');const n=e.autoVacuum==null||e.autoVacuum===true?P:e.autoVacuum;this._options={...$,...e,autoVacuum:n,searchOptions:{...rt,...e.searchOptions},autoSuggestOptions:{...Et,...e.autoSuggestOptions}},this._index=new I,this._documentCount=0,this._documentIds=new Map,this._idToShortId=new Map,this._fieldIds={},this._fieldLength=new Map,this._avgFieldLength=[],this._nextId=0,this._storedFields=new Map,this._dirtCount=0,this._currentVacuum=null,this._enqueuedVacuum=null,this._enqueuedVacuumConditions=W,this.addFields(this._options.fields);}get isVacuuming(){return this._currentVacuum!=null}get dirtCount(){return this._dirtCount}get dirtFactor(){return this._dirtCount/(1+this._documentCount+this._dirtCount)}get documentCount(){return this._documentCount}get termCount(){return this._index.size}toJSON(){const e=[];for(const[n,o]of this._index){const s={};for(const[r,i]of o)s[r]=Object.fromEntries(i);e.push([n,s]);}return {documentCount:this._documentCount,nextId:this._nextId,documentIds:Object.fromEntries(this._documentIds),fieldIds:this._fieldIds,fieldLength:Object.fromEntries(this._fieldLength),averageFieldLength:this._avgFieldLength,storedFields:Object.fromEntries(this._storedFields),dirtCount:this._dirtCount,index:e,version:2}}addFields(e){for(let n=0;n<e.length;n++)this._fieldIds[e[n]]=n;}}const lt=t=>new Nt(t);
 
 /**
  * Generates a list of accent variants for a given term.
@@ -14992,7 +15685,7 @@ const generateAccentVariants = (term) => {
 
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.7
 //   protoc               v4.23.4
 // source: src/stops/proto/stops.proto
 /* eslint-disable */
@@ -15089,7 +15782,7 @@ const Stop = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStop();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -15171,7 +15864,7 @@ const Stop = {
             sourceStopId: isSet$1(object.sourceStopId) ? globalThis.String(object.sourceStopId) : "",
             lat: isSet$1(object.lat) ? globalThis.Number(object.lat) : undefined,
             lon: isSet$1(object.lon) ? globalThis.Number(object.lon) : undefined,
-            children: globalThis.Array.isArray(object === null || object === undefined ? undefined : object.children) ? object.children.map((e) => globalThis.Number(e)) : [],
+            children: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.children) ? object.children.map((e) => globalThis.Number(e)) : [],
             parent: isSet$1(object.parent) ? globalThis.Number(object.parent) : undefined,
             locationType: isSet$1(object.locationType) ? locationTypeFromJSON(object.locationType) : 0,
             platform: isSet$1(object.platform) ? globalThis.String(object.platform) : undefined,
@@ -15192,7 +15885,7 @@ const Stop = {
         if (message.lon !== undefined) {
             obj.lon = message.lon;
         }
-        if ((_a = message.children) === null || _a === undefined ? undefined : _a.length) {
+        if ((_a = message.children) === null || _a === void 0 ? void 0 : _a.length) {
             obj.children = message.children.map((e) => Math.round(e));
         }
         if (message.parent !== undefined) {
@@ -15207,19 +15900,19 @@ const Stop = {
         return obj;
     },
     create(base) {
-        return Stop.fromPartial(base !== null && base !== undefined ? base : {});
+        return Stop.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         const message = createBaseStop();
-        message.name = (_a = object.name) !== null && _a !== undefined ? _a : "";
-        message.sourceStopId = (_b = object.sourceStopId) !== null && _b !== undefined ? _b : "";
-        message.lat = (_c = object.lat) !== null && _c !== undefined ? _c : undefined;
-        message.lon = (_d = object.lon) !== null && _d !== undefined ? _d : undefined;
-        message.children = ((_e = object.children) === null || _e === undefined ? undefined : _e.map((e) => e)) || [];
-        message.parent = (_f = object.parent) !== null && _f !== undefined ? _f : undefined;
-        message.locationType = (_g = object.locationType) !== null && _g !== undefined ? _g : 0;
-        message.platform = (_h = object.platform) !== null && _h !== undefined ? _h : undefined;
+        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
+        message.sourceStopId = (_b = object.sourceStopId) !== null && _b !== void 0 ? _b : "";
+        message.lat = (_c = object.lat) !== null && _c !== void 0 ? _c : undefined;
+        message.lon = (_d = object.lon) !== null && _d !== void 0 ? _d : undefined;
+        message.children = ((_e = object.children) === null || _e === void 0 ? void 0 : _e.map((e) => e)) || [];
+        message.parent = (_f = object.parent) !== null && _f !== void 0 ? _f : undefined;
+        message.locationType = (_g = object.locationType) !== null && _g !== void 0 ? _g : 0;
+        message.platform = (_h = object.platform) !== null && _h !== void 0 ? _h : undefined;
         return message;
     },
 };
@@ -15238,7 +15931,7 @@ const StopsMap = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStopsMap();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -15296,13 +15989,13 @@ const StopsMap = {
         return obj;
     },
     create(base) {
-        return StopsMap.fromPartial(base !== null && base !== undefined ? base : {});
+        return StopsMap.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseStopsMap();
-        message.version = (_a = object.version) !== null && _a !== undefined ? _a : "";
-        message.stops = Object.entries((_b = object.stops) !== null && _b !== undefined ? _b : {}).reduce((acc, [key, value]) => {
+        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : "";
+        message.stops = Object.entries((_b = object.stops) !== null && _b !== void 0 ? _b : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
                 acc[globalThis.Number(key)] = Stop.fromPartial(value);
             }
@@ -15326,7 +16019,7 @@ const StopsMap_StopsEntry = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStopsMap_StopsEntry();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -15370,12 +16063,12 @@ const StopsMap_StopsEntry = {
         return obj;
     },
     create(base) {
-        return StopsMap_StopsEntry.fromPartial(base !== null && base !== undefined ? base : {});
+        return StopsMap_StopsEntry.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseStopsMap_StopsEntry();
-        message.key = (_a = object.key) !== null && _a !== undefined ? _a : 0;
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : 0;
         message.value = (object.value !== undefined && object.value !== null) ? Stop.fromPartial(object.value) : undefined;
         return message;
     },
@@ -15486,7 +16179,7 @@ class StopsIndex {
         });
         const stopsSet = new Map();
         for (const [id, stop] of stopsMap.entries()) {
-            const effectiveStopId = (_a = stop.parent) !== null && _a !== undefined ? _a : id;
+            const effectiveStopId = (_a = stop.parent) !== null && _a !== void 0 ? _a : id;
             if (!stopsSet.has(effectiveStopId)) {
                 stopsSet.set(effectiveStopId, {
                     id: effectiveStopId,
@@ -15517,8 +16210,8 @@ class StopsIndex {
     /**
      * Deserializes a binary representation of the stops.
      *
-     * @param {Uint8Array} data - The binary data to deserialize.
-     * @returns {StopsMap} - The deserialized StopFinder.
+     * @param data - The binary data to deserialize.
+     * @returns The deserialized StopFinder.
      */
     static fromData(data) {
         const reader = new BinaryReader(data);
@@ -15528,7 +16221,7 @@ class StopsIndex {
     /**
      * Serializes the stops into a binary protobuf.
      *
-     * @returns {Uint8Array} - The serialized binary data.
+     * @returns The serialized binary data.
      */
     serialize() {
         const protoStopsMap = serializeStopsMap(this.stopsMap);
@@ -15607,7 +16300,7 @@ class StopsIndex {
             return [];
         }
         const equivalentStops = stop.parent
-            ? ((_b = (_a = this.stopsMap.get(stop.parent)) === null || _a === undefined ? undefined : _a.children) !== null && _b !== undefined ? _b : [])
+            ? ((_b = (_a = this.stopsMap.get(stop.parent)) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [])
             : stop.children;
         return Array.from(new Set([id, ...equivalentStops])).map((stopId) => this.stopsMap.get(stopId));
     }
@@ -15696,7 +16389,7 @@ class Duration {
 
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.7
 //   protoc               v4.23.4
 // source: src/timetable/proto/timetable.proto
 /* eslint-disable */
@@ -15830,7 +16523,7 @@ function createBaseRoute() {
         serviceRouteId: "",
     };
 }
-const Route$1 = {
+const Route$2 = {
     encode(message, writer = new BinaryWriter()) {
         if (message.stopTimes.length !== 0) {
             writer.uint32(10).bytes(message.stopTimes);
@@ -15848,7 +16541,7 @@ const Route$1 = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseRoute();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -15916,15 +16609,15 @@ const Route$1 = {
         return obj;
     },
     create(base) {
-        return Route$1.fromPartial(base !== null && base !== undefined ? base : {});
+        return Route$2.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c, _d;
         const message = createBaseRoute();
-        message.stopTimes = (_a = object.stopTimes) !== null && _a !== undefined ? _a : new Uint8Array(0);
-        message.pickUpDropOffTypes = (_b = object.pickUpDropOffTypes) !== null && _b !== undefined ? _b : new Uint8Array(0);
-        message.stops = (_c = object.stops) !== null && _c !== undefined ? _c : new Uint8Array(0);
-        message.serviceRouteId = (_d = object.serviceRouteId) !== null && _d !== undefined ? _d : "";
+        message.stopTimes = (_a = object.stopTimes) !== null && _a !== void 0 ? _a : new Uint8Array(0);
+        message.pickUpDropOffTypes = (_b = object.pickUpDropOffTypes) !== null && _b !== void 0 ? _b : new Uint8Array(0);
+        message.stops = (_c = object.stops) !== null && _c !== void 0 ? _c : new Uint8Array(0);
+        message.serviceRouteId = (_d = object.serviceRouteId) !== null && _d !== void 0 ? _d : "";
         return message;
     },
 };
@@ -15940,7 +16633,7 @@ const RoutesAdjacency = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseRoutesAdjacency();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -15967,7 +16660,7 @@ const RoutesAdjacency = {
         return {
             routes: isObject(object.routes)
                 ? Object.entries(object.routes).reduce((acc, [key, value]) => {
-                    acc[key] = Route$1.fromJSON(value);
+                    acc[key] = Route$2.fromJSON(value);
                     return acc;
                 }, {})
                 : {},
@@ -15980,21 +16673,21 @@ const RoutesAdjacency = {
             if (entries.length > 0) {
                 obj.routes = {};
                 entries.forEach(([k, v]) => {
-                    obj.routes[k] = Route$1.toJSON(v);
+                    obj.routes[k] = Route$2.toJSON(v);
                 });
             }
         }
         return obj;
     },
     create(base) {
-        return RoutesAdjacency.fromPartial(base !== null && base !== undefined ? base : {});
+        return RoutesAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseRoutesAdjacency();
-        message.routes = Object.entries((_a = object.routes) !== null && _a !== undefined ? _a : {}).reduce((acc, [key, value]) => {
+        message.routes = Object.entries((_a = object.routes) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
-                acc[key] = Route$1.fromPartial(value);
+                acc[key] = Route$2.fromPartial(value);
             }
             return acc;
         }, {});
@@ -16010,13 +16703,13 @@ const RoutesAdjacency_RoutesEntry = {
             writer.uint32(10).string(message.key);
         }
         if (message.value !== undefined) {
-            Route$1.encode(message.value, writer.uint32(18).fork()).join();
+            Route$2.encode(message.value, writer.uint32(18).fork()).join();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseRoutesAdjacency_RoutesEntry();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16032,7 +16725,7 @@ const RoutesAdjacency_RoutesEntry = {
                     if (tag !== 18) {
                         break;
                     }
-                    message.value = Route$1.decode(reader, reader.uint32());
+                    message.value = Route$2.decode(reader, reader.uint32());
                     continue;
                 }
             }
@@ -16046,7 +16739,7 @@ const RoutesAdjacency_RoutesEntry = {
     fromJSON(object) {
         return {
             key: isSet(object.key) ? globalThis.String(object.key) : "",
-            value: isSet(object.value) ? Route$1.fromJSON(object.value) : undefined,
+            value: isSet(object.value) ? Route$2.fromJSON(object.value) : undefined,
         };
     },
     toJSON(message) {
@@ -16055,18 +16748,18 @@ const RoutesAdjacency_RoutesEntry = {
             obj.key = message.key;
         }
         if (message.value !== undefined) {
-            obj.value = Route$1.toJSON(message.value);
+            obj.value = Route$2.toJSON(message.value);
         }
         return obj;
     },
     create(base) {
-        return RoutesAdjacency_RoutesEntry.fromPartial(base !== null && base !== undefined ? base : {});
+        return RoutesAdjacency_RoutesEntry.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseRoutesAdjacency_RoutesEntry();
-        message.key = (_a = object.key) !== null && _a !== undefined ? _a : "";
-        message.value = (object.value !== undefined && object.value !== null) ? Route$1.fromPartial(object.value) : undefined;
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
+        message.value = (object.value !== undefined && object.value !== null) ? Route$2.fromPartial(object.value) : undefined;
         return message;
     },
 };
@@ -16088,7 +16781,7 @@ const Transfer = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseTransfer();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16143,14 +16836,14 @@ const Transfer = {
         return obj;
     },
     create(base) {
-        return Transfer.fromPartial(base !== null && base !== undefined ? base : {});
+        return Transfer.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a, _b, _c;
         const message = createBaseTransfer();
-        message.destination = (_a = object.destination) !== null && _a !== undefined ? _a : 0;
-        message.type = (_b = object.type) !== null && _b !== undefined ? _b : 0;
-        message.minTransferTime = (_c = object.minTransferTime) !== null && _c !== undefined ? _c : undefined;
+        message.destination = (_a = object.destination) !== null && _a !== void 0 ? _a : 0;
+        message.type = (_b = object.type) !== null && _b !== void 0 ? _b : 0;
+        message.minTransferTime = (_c = object.minTransferTime) !== null && _c !== void 0 ? _c : undefined;
         return message;
     },
 };
@@ -16166,7 +16859,7 @@ const StopsAdjacency = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStopsAdjacency();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16213,12 +16906,12 @@ const StopsAdjacency = {
         return obj;
     },
     create(base) {
-        return StopsAdjacency.fromPartial(base !== null && base !== undefined ? base : {});
+        return StopsAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseStopsAdjacency();
-        message.stops = Object.entries((_a = object.stops) !== null && _a !== undefined ? _a : {}).reduce((acc, [key, value]) => {
+        message.stops = Object.entries((_a = object.stops) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
                 acc[key] = StopsAdjacency_StopAdjacency.fromPartial(value);
             }
@@ -16242,7 +16935,7 @@ const StopsAdjacency_StopAdjacency = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStopsAdjacency_StopAdjacency();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16271,31 +16964,31 @@ const StopsAdjacency_StopAdjacency = {
     },
     fromJSON(object) {
         return {
-            transfers: globalThis.Array.isArray(object === null || object === undefined ? undefined : object.transfers)
+            transfers: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.transfers)
                 ? object.transfers.map((e) => Transfer.fromJSON(e))
                 : [],
-            routes: globalThis.Array.isArray(object === null || object === undefined ? undefined : object.routes) ? object.routes.map((e) => globalThis.String(e)) : [],
+            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.String(e)) : [],
         };
     },
     toJSON(message) {
         var _a, _b;
         const obj = {};
-        if ((_a = message.transfers) === null || _a === undefined ? undefined : _a.length) {
+        if ((_a = message.transfers) === null || _a === void 0 ? void 0 : _a.length) {
             obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
         }
-        if ((_b = message.routes) === null || _b === undefined ? undefined : _b.length) {
+        if ((_b = message.routes) === null || _b === void 0 ? void 0 : _b.length) {
             obj.routes = message.routes;
         }
         return obj;
     },
     create(base) {
-        return StopsAdjacency_StopAdjacency.fromPartial(base !== null && base !== undefined ? base : {});
+        return StopsAdjacency_StopAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseStopsAdjacency_StopAdjacency();
-        message.transfers = ((_a = object.transfers) === null || _a === undefined ? undefined : _a.map((e) => Transfer.fromPartial(e))) || [];
-        message.routes = ((_b = object.routes) === null || _b === undefined ? undefined : _b.map((e) => e)) || [];
+        message.transfers = ((_a = object.transfers) === null || _a === void 0 ? void 0 : _a.map((e) => Transfer.fromPartial(e))) || [];
+        message.routes = ((_b = object.routes) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
         return message;
     },
 };
@@ -16314,7 +17007,7 @@ const StopsAdjacency_StopsEntry = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseStopsAdjacency_StopsEntry();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16358,12 +17051,12 @@ const StopsAdjacency_StopsEntry = {
         return obj;
     },
     create(base) {
-        return StopsAdjacency_StopsEntry.fromPartial(base !== null && base !== undefined ? base : {});
+        return StopsAdjacency_StopsEntry.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseStopsAdjacency_StopsEntry();
-        message.key = (_a = object.key) !== null && _a !== undefined ? _a : "";
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
         message.value = (object.value !== undefined && object.value !== null)
             ? StopsAdjacency_StopAdjacency.fromPartial(object.value)
             : undefined;
@@ -16385,7 +17078,7 @@ const ServiceRoute = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseServiceRoute();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16429,13 +17122,13 @@ const ServiceRoute = {
         return obj;
     },
     create(base) {
-        return ServiceRoute.fromPartial(base !== null && base !== undefined ? base : {});
+        return ServiceRoute.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a, _b;
         const message = createBaseServiceRoute();
-        message.type = (_a = object.type) !== null && _a !== undefined ? _a : 0;
-        message.name = (_b = object.name) !== null && _b !== undefined ? _b : "";
+        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
+        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
         return message;
     },
 };
@@ -16451,7 +17144,7 @@ const ServiceRoutesMap = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseServiceRoutesMap();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16498,12 +17191,12 @@ const ServiceRoutesMap = {
         return obj;
     },
     create(base) {
-        return ServiceRoutesMap.fromPartial(base !== null && base !== undefined ? base : {});
+        return ServiceRoutesMap.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseServiceRoutesMap();
-        message.routes = Object.entries((_a = object.routes) !== null && _a !== undefined ? _a : {}).reduce((acc, [key, value]) => {
+        message.routes = Object.entries((_a = object.routes) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
                 acc[key] = ServiceRoute.fromPartial(value);
             }
@@ -16527,7 +17220,7 @@ const ServiceRoutesMap_RoutesEntry = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseServiceRoutesMap_RoutesEntry();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16571,12 +17264,12 @@ const ServiceRoutesMap_RoutesEntry = {
         return obj;
     },
     create(base) {
-        return ServiceRoutesMap_RoutesEntry.fromPartial(base !== null && base !== undefined ? base : {});
+        return ServiceRoutesMap_RoutesEntry.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseServiceRoutesMap_RoutesEntry();
-        message.key = (_a = object.key) !== null && _a !== undefined ? _a : "";
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
         message.value = (object.value !== undefined && object.value !== null)
             ? ServiceRoute.fromPartial(object.value)
             : undefined;
@@ -16604,7 +17297,7 @@ const Timetable$1 = {
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
+        const end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseTimetable();
         while (reader.pos < end) {
             const tag = reader.uint32();
@@ -16670,12 +17363,12 @@ const Timetable$1 = {
         return obj;
     },
     create(base) {
-        return Timetable$1.fromPartial(base !== null && base !== undefined ? base : {});
+        return Timetable$1.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
         var _a;
         const message = createBaseTimetable();
-        message.version = (_a = object.version) !== null && _a !== undefined ? _a : "";
+        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : "";
         message.stopsAdjacency = (object.stopsAdjacency !== undefined && object.stopsAdjacency !== null)
             ? StopsAdjacency.fromPartial(object.stopsAdjacency)
             : undefined;
@@ -16720,231 +17413,6 @@ function isSet(value) {
     return value !== null && value !== undefined;
 }
 
-const isLittleEndian = (() => {
-    const buffer = new ArrayBuffer(4);
-    const view = new DataView(buffer);
-    view.setUint32(0, 0x12345678);
-    return new Uint8Array(buffer)[0] === 0x78;
-})();
-const STANDARD_ENDIANNESS = true; // true = little-endian
-function uint32ArrayToBytes(array) {
-    if (isLittleEndian === STANDARD_ENDIANNESS) {
-        return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-    }
-    // If endianness doesn't match, we need to swap byte order
-    const result = new Uint8Array(array.length * 4);
-    const view = new DataView(result.buffer);
-    for (let i = 0; i < array.length; i++) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        view.setUint32(i * 4, array[i], STANDARD_ENDIANNESS);
-    }
-    return result;
-}
-function bytesToUint32Array(bytes) {
-    if (bytes.byteLength % 4 !== 0) {
-        throw new Error('Byte array length must be a multiple of 4 to convert to Uint32Array');
-    }
-    // If system endianness matches our standard, we can create a view directly
-    if (isLittleEndian === STANDARD_ENDIANNESS) {
-        return new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
-    }
-    // If endianness doesn't match, we need to swap byte order
-    const result = new Uint32Array(bytes.byteLength / 4);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    for (let i = 0; i < result.length; i++) {
-        result[i] = view.getUint32(i * 4, STANDARD_ENDIANNESS);
-    }
-    return result;
-}
-function uint16ArrayToBytes(array) {
-    if (isLittleEndian === STANDARD_ENDIANNESS) {
-        return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-    }
-    // If endianness doesn't match, we need to swap byte order
-    const result = new Uint8Array(array.length * 2);
-    const view = new DataView(result.buffer);
-    for (let i = 0; i < array.length; i++) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        view.setUint16(i * 2, array[i], STANDARD_ENDIANNESS);
-    }
-    return result;
-}
-function bytesToUint16Array(bytes) {
-    if (bytes.byteLength % 2 !== 0) {
-        throw new Error('Byte array length must be a multiple of 2 to convert to Uint16Array');
-    }
-    // If system endianness matches our standard, we can create a view directly
-    if (isLittleEndian === STANDARD_ENDIANNESS) {
-        return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
-    }
-    // If endianness doesn't match, we need to swap byte order
-    const result = new Uint16Array(bytes.byteLength / 2);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    for (let i = 0; i < result.length; i++) {
-        result[i] = view.getUint16(i * 2, STANDARD_ENDIANNESS);
-    }
-    return result;
-}
-const serializeStopsAdjacency = (stopsAdjacency) => {
-    const protoStopsAdjacency = {
-        stops: {},
-    };
-    stopsAdjacency.forEach((value, key) => {
-        protoStopsAdjacency.stops[key] = {
-            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
-                minTransferTime: transfer.minTransferTime.toSeconds(),
-            })))),
-            routes: value.routes,
-        };
-    });
-    return protoStopsAdjacency;
-};
-const serializeRoutesAdjacency = (routesAdjacency) => {
-    const protoRoutesAdjacency = {
-        routes: {},
-    };
-    routesAdjacency.forEach((value, key) => {
-        protoRoutesAdjacency.routes[key] = {
-            stopTimes: uint16ArrayToBytes(value.stopTimes),
-            pickUpDropOffTypes: value.pickUpDropOffTypes,
-            stops: uint32ArrayToBytes(value.stops),
-            serviceRouteId: value.serviceRouteId,
-        };
-    });
-    return protoRoutesAdjacency;
-};
-const serializeServiceRoutesMap = (serviceRoutesMap) => {
-    const protoServiceRoutesMap = {
-        routes: {},
-    };
-    serviceRoutesMap.forEach((value, key) => {
-        protoServiceRoutesMap.routes[key] = {
-            type: serializeRouteType(value.type),
-            name: value.name,
-        };
-    });
-    return protoServiceRoutesMap;
-};
-const deserializeStopsAdjacency = (protoStopsAdjacency) => {
-    const stopsAdjacency = new Map();
-    Object.entries(protoStopsAdjacency.stops).forEach(([keyStr, value]) => {
-        const key = parseInt(keyStr, 10);
-        stopsAdjacency.set(key, {
-            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: parseTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
-                minTransferTime: Duration.fromSeconds(transfer.minTransferTime),
-            })))),
-            routes: value.routes,
-        });
-    });
-    return stopsAdjacency;
-};
-const deserializeRoutesAdjacency = (protoRoutesAdjacency) => {
-    const routesAdjacency = new Map();
-    Object.entries(protoRoutesAdjacency.routes).forEach(([key, value]) => {
-        const stops = bytesToUint32Array(value.stops);
-        const indices = new Map();
-        for (let i = 0; i < stops.length; i++) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            indices.set(stops[i], i);
-        }
-        routesAdjacency.set(key, {
-            stopTimes: bytesToUint16Array(value.stopTimes),
-            pickUpDropOffTypes: value.pickUpDropOffTypes,
-            stops: stops,
-            stopIndices: indices,
-            serviceRouteId: value.serviceRouteId,
-        });
-    });
-    return routesAdjacency;
-};
-const deserializeServiceRoutesMap = (protoServiceRoutesMap) => {
-    const serviceRoutesMap = new Map();
-    Object.entries(protoServiceRoutesMap.routes).forEach(([key, value]) => {
-        serviceRoutesMap.set(key, {
-            type: parseRouteType(value.type),
-            name: value.name,
-        });
-    });
-    return serviceRoutesMap;
-};
-const parseTransferType = (type) => {
-    switch (type) {
-        case TransferType.RECOMMENDED_TRANSFER_POINT:
-            return 'RECOMMENDED';
-        case TransferType.TIMED_TRANSFER:
-            return 'GUARANTEED';
-        case TransferType.REQUIRES_MINIMAL_TIME:
-            return 'REQUIRES_MINIMAL_TIME';
-        case TransferType.IN_SEAT_TRANSFER:
-            return 'IN_SEAT';
-        case TransferType.UNRECOGNIZED:
-            throw new Error('Unrecognized protobuf transfer type.');
-    }
-};
-const serializeTransferType = (type) => {
-    switch (type) {
-        case 'RECOMMENDED':
-            return TransferType.RECOMMENDED_TRANSFER_POINT;
-        case 'GUARANTEED':
-            return TransferType.TIMED_TRANSFER;
-        case 'REQUIRES_MINIMAL_TIME':
-            return TransferType.REQUIRES_MINIMAL_TIME;
-        case 'IN_SEAT':
-            return TransferType.IN_SEAT_TRANSFER;
-    }
-};
-const parseRouteType = (type) => {
-    switch (type) {
-        case RouteType.TRAM:
-            return 'TRAM';
-        case RouteType.SUBWAY:
-            return 'SUBWAY';
-        case RouteType.RAIL:
-            return 'RAIL';
-        case RouteType.BUS:
-            return 'BUS';
-        case RouteType.FERRY:
-            return 'FERRY';
-        case RouteType.CABLE_TRAM:
-            return 'CABLE_TRAM';
-        case RouteType.AERIAL_LIFT:
-            return 'AERIAL_LIFT';
-        case RouteType.FUNICULAR:
-            return 'FUNICULAR';
-        case RouteType.TROLLEYBUS:
-            return 'TROLLEYBUS';
-        case RouteType.MONORAIL:
-            return 'MONORAIL';
-        case RouteType.UNRECOGNIZED:
-        default:
-            throw new Error('Unrecognized protobuf route type.');
-    }
-};
-const serializeRouteType = (type) => {
-    switch (type) {
-        case 'TRAM':
-            return RouteType.TRAM;
-        case 'SUBWAY':
-            return RouteType.SUBWAY;
-        case 'RAIL':
-            return RouteType.RAIL;
-        case 'BUS':
-            return RouteType.BUS;
-        case 'FERRY':
-            return RouteType.FERRY;
-        case 'CABLE_TRAM':
-            return RouteType.CABLE_TRAM;
-        case 'AERIAL_LIFT':
-            return RouteType.AERIAL_LIFT;
-        case 'FUNICULAR':
-            return RouteType.FUNICULAR;
-        case 'TROLLEYBUS':
-            return RouteType.TROLLEYBUS;
-        case 'MONORAIL':
-            return RouteType.MONORAIL;
-    }
-};
-
 /**
  * A class representing a time as minutes since midnight.
  */
@@ -17034,9 +17502,12 @@ class Time {
         const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
         if (hoursStr === undefined ||
             minutesStr === undefined ||
+            hoursStr.trim() === '' ||
+            minutesStr.trim() === '' ||
             isNaN(Number(hoursStr)) ||
             isNaN(Number(minutesStr)) ||
-            (secondsStr !== undefined && isNaN(Number(secondsStr)))) {
+            (secondsStr !== undefined &&
+                (secondsStr.trim() === '' || isNaN(Number(secondsStr))))) {
             throw new Error('Input string must be in the format "HH:MM:SS" or "HH:MM".');
         }
         const hours = parseInt(hoursStr, 10);
@@ -17050,8 +17521,11 @@ class Time {
      * @returns A string representing the time.
      */
     toString() {
-        const hours = Math.floor(this.minutesSinceMidnight / 60);
+        let hours = Math.floor(this.minutesSinceMidnight / 60);
         const minutes = Math.floor(this.minutesSinceMidnight % 60);
+        if (hours >= 24) {
+            hours = hours % 24;
+        }
         return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
     }
     /**
@@ -17106,9 +17580,7 @@ class Time {
             throw new Error('At least one Time instance is required.');
         }
         return times.reduce((maxTime, currentTime) => {
-            return currentTime.toMinutes() > maxTime.toMinutes()
-                ? currentTime
-                : maxTime;
+            return currentTime.isAfter(maxTime) ? currentTime : maxTime;
         });
     }
     /**
@@ -17122,18 +17594,476 @@ class Time {
             throw new Error('At least one Time instance is required.');
         }
         return times.reduce((minTime, currentTime) => {
-            return currentTime.toMinutes() < minTime.toMinutes()
-                ? currentTime
-                : minTime;
+            return currentTime.isBefore(minTime) ? currentTime : minTime;
         });
     }
+    /**
+     * Determines if the current Time instance is after another Time instance.
+     *
+     * @param otherTime - A Time instance to compare against.
+     * @returns True if the current Time instance is after the other Time instance, otherwise false.
+     */
+    isAfter(otherTime) {
+        return this.minutesSinceMidnight > otherTime.toMinutes();
+    }
+    /**
+     * Determines if the current Time instance is before another Time instance.
+     *
+     * @param otherTime - A Time instance to compare against.
+     * @returns True if the current Time instance is before the other Time instance, otherwise false.
+     */
+    isBefore(otherTime) {
+        return this.minutesSinceMidnight < otherTime.toMinutes();
+    }
+    /**
+     * Determines if the current Time instance is equal to another Time instance.
+     *
+     * @param otherTime - A Time instance to compare against.
+     * @returns True if the current Time instance is equal to the other Time instance, otherwise false.
+     */
+    equals(otherTime) {
+        return this.minutesSinceMidnight === otherTime.toMinutes();
+    }
 }
 
 const REGULAR = 0;
 const NOT_AVAILABLE = 1;
 const MUST_PHONE_AGENCY = 2;
 const MUST_COORDINATE_WITH_DRIVER = 3;
-const ALL_TRANSPORT_MODES = [
+const pickUpDropOffTypeMap = [
+    'REGULAR',
+    'NOT_AVAILABLE',
+    'MUST_PHONE_AGENCY',
+    'MUST_COORDINATE_WITH_DRIVER',
+];
+/**
+ * Converts a numerical representation of a pick-up/drop-off type
+ * into its corresponding string representation.
+ *
+ * @param numericalType - The numerical value representing the pick-up/drop-off type.
+ * @returns The corresponding PickUpDropOffType as a string.
+ * @throws An error if the numerical type is invalid.
+ */
+const toPickupDropOffType = (numericalType) => {
+    const type = pickUpDropOffTypeMap[numericalType];
+    if (!type) {
+        throw new Error(`Invalid pickup/drop-off type ${numericalType}`);
+    }
+    return type;
+};
+/**
+ * A route identifies all trips of a given service route sharing the same list of stops.
+ */
+let Route$1 = class Route {
+    constructor(stopTimes, pickUpDropOffTypes, stops, serviceRouteId) {
+        this.stopTimes = stopTimes;
+        this.pickUpDropOffTypes = pickUpDropOffTypes;
+        this.stops = stops;
+        this.serviceRouteId = serviceRouteId;
+        this.nbStops = stops.length;
+        this.nbTrips = this.stopTimes.length / (this.stops.length * 2);
+        this.stopIndices = new Map();
+        for (let i = 0; i < stops.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.stopIndices.set(stops[i], i);
+        }
+    }
+    /**
+     * Serializes the Route into binary arrays.
+     *
+     * @returns The serialized binary data.
+     */
+    serialize() {
+        return {
+            stopTimes: this.stopTimes,
+            pickUpDropOffTypes: this.pickUpDropOffTypes,
+            stops: this.stops,
+            serviceRouteId: this.serviceRouteId,
+        };
+    }
+    /**
+     * Checks if stop A is before stop B in the route.
+     *
+     * @param stopA - The StopId of the first stop.
+     * @param stopB - The StopId of the second stop.
+     * @returns True if stop A is before stop B, false otherwise.
+     */
+    isBefore(stopA, stopB) {
+        const stopAIndex = this.stopIndices.get(stopA);
+        if (stopAIndex === undefined) {
+            throw new Error(`Stop index ${stopAIndex} not found in route ${this.serviceRouteId}`);
+        }
+        const stopBIndex = this.stopIndices.get(stopB);
+        if (stopBIndex === undefined) {
+            throw new Error(`Stop index ${stopBIndex} not found in route ${this.serviceRouteId}`);
+        }
+        return stopAIndex < stopBIndex;
+    }
+    /**
+     * Retrieves the number of stops in the route.
+     *
+     * @returns The total number of stops in the route.
+     */
+    getNbStops() {
+        return this.nbStops;
+    }
+    /**
+     * Finds the ServiceRouteId of the route. It corresponds the identifier
+     * of the service shown to the end user as a route.
+     *
+     * @returns The ServiceRouteId of the route.
+     */
+    serviceRoute() {
+        return this.serviceRouteId;
+    }
+    /**
+     * Retrieves the arrival time at a specific stop for a given trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The arrival time at the specified stop and trip as a Time object.
+     */
+    arrivalAt(stopId, tripIndex) {
+        const arrivalIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2;
+        const arrival = this.stopTimes[arrivalIndex];
+        if (arrival === undefined) {
+            throw new Error(`Arrival time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+        }
+        return Time.fromMinutes(arrival);
+    }
+    /**
+     * Retrieves the departure time at a specific stop for a given trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The departure time at the specified stop and trip as a Time object.
+     */
+    departureFrom(stopId, tripIndex) {
+        const departureIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2 + 1;
+        const departure = this.stopTimes[departureIndex];
+        if (departure === undefined) {
+            throw new Error(`Departure time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+        }
+        return Time.fromMinutes(departure);
+    }
+    /**
+     * Retrieves the pick-up type for a specific stop and trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The pick-up type at the specified stop and trip.
+     */
+    pickUpTypeFrom(stopId, tripIndex) {
+        const pickUpIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2;
+        const pickUpValue = this.pickUpDropOffTypes[pickUpIndex];
+        if (pickUpValue === undefined) {
+            throw new Error(`Pick up type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+        }
+        return toPickupDropOffType(pickUpValue);
+    }
+    /**
+     * Retrieves the drop-off type for a specific stop and trip.
+     *
+     * @param stopId - The identifier of the stop.
+     * @param tripIndex - The index of the trip.
+     * @returns The drop-off type at the specified stop and trip.
+     */
+    dropOffTypeAt(stopId, tripIndex) {
+        const dropOffIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2 + 1;
+        const dropOffValue = this.pickUpDropOffTypes[dropOffIndex];
+        if (dropOffValue === undefined) {
+            throw new Error(`Drop off type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+        }
+        return toPickupDropOffType(dropOffValue);
+    }
+    /**
+     * Iterates over the stops in the route, starting from an optional specified stop.
+     * If no start stop is provided, the iteration begins from the first stop in the route.
+     *
+     * @param [startStopId] - (Optional) The StopId of the stop to start the iteration from.
+     * @returns An IterableIterator of StopIds, starting from the specified stop or the first stop.
+     * @throws An error if the specified start stop is not found in the route.
+     */
+    stopsIterator(startStopId) {
+        const startIndex = startStopId !== undefined ? this.stopIndices.get(startStopId) : 0;
+        if (startIndex === undefined) {
+            throw new Error(`Start stop ${startStopId} not found in route ${this.serviceRouteId}`);
+        }
+        function* generator(stops, startIndex) {
+            for (let i = startIndex; i < stops.length; i++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                yield stops[i];
+            }
+        }
+        return generator(this.stops, startIndex);
+    }
+    /**
+     * Finds the earliest trip that can be taken from a specific stop on a given route,
+     * optionally constrained by a latest trip index and a time before which the trip
+     * should not depart.
+     * *
+     * @param stopId - The StopId of the stop where the trip should be found.
+     * @param [after=Time.origin()] - The earliest time after which the trip should depart.
+     *                                    If not provided, searches all available trips.
+     * @param [beforeTrip] - (Optional) The index of the trip before which the search should be constrained.
+     *                                   If not provided, searches all available trips.
+     * @returns The index of the earliest trip meeting the criteria, or undefined if no such trip is found.
+     */
+    findEarliestTrip(stopId, after = Time.origin(), beforeTrip) {
+        const maxTripIndex = beforeTrip !== undefined
+            ? Math.min(beforeTrip - 1, this.nbTrips - 1)
+            : this.nbTrips - 1;
+        if (maxTripIndex < 0) {
+            return undefined;
+        }
+        let earliestTripIndex;
+        let lowTrip = 0;
+        let highTrip = maxTripIndex;
+        while (lowTrip <= highTrip) {
+            const midTrip = Math.floor((lowTrip + highTrip) / 2);
+            const departure = this.departureFrom(stopId, midTrip);
+            const pickUpType = this.pickUpTypeFrom(stopId, midTrip);
+            if ((departure.isAfter(after) || departure.equals(after)) &&
+                pickUpType !== 'NOT_AVAILABLE') {
+                earliestTripIndex = midTrip;
+                highTrip = midTrip - 1;
+            }
+            else {
+                lowTrip = midTrip + 1;
+            }
+        }
+        return earliestTripIndex;
+    }
+    /**
+     * Retrieves the index of a stop within the route.
+     * @param stopId The StopId of the stop to locate in the route.
+     * @returns The index of the stop in the route.
+     */
+    stopIndex(stopId) {
+        const stopIndex = this.stopIndices.get(stopId);
+        if (stopIndex === undefined) {
+            throw new Error(`Stop index for ${stopId} not found in route ${this.serviceRouteId}`);
+        }
+        return stopIndex;
+    }
+};
+
+const isLittleEndian = (() => {
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setUint32(0, 0x12345678);
+    return new Uint8Array(buffer)[0] === 0x78;
+})();
+const STANDARD_ENDIANNESS = true; // true = little-endian
+const uint32ArrayToBytes = (array) => {
+    if (isLittleEndian === STANDARD_ENDIANNESS) {
+        return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    }
+    // If endianness doesn't match, we need to swap byte order
+    const result = new Uint8Array(array.length * 4);
+    const view = new DataView(result.buffer);
+    for (let i = 0; i < array.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        view.setUint32(i * 4, array[i], STANDARD_ENDIANNESS);
+    }
+    return result;
+};
+const bytesToUint32Array = (bytes) => {
+    if (bytes.byteLength % 4 !== 0) {
+        throw new Error('Byte array length must be a multiple of 4 to convert to Uint32Array');
+    }
+    // If system endianness matches our standard, we can create a view directly
+    if (isLittleEndian === STANDARD_ENDIANNESS) {
+        return new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+    }
+    // If endianness doesn't match, we need to swap byte order
+    const result = new Uint32Array(bytes.byteLength / 4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let i = 0; i < result.length; i++) {
+        result[i] = view.getUint32(i * 4, STANDARD_ENDIANNESS);
+    }
+    return result;
+};
+const uint16ArrayToBytes = (array) => {
+    if (isLittleEndian === STANDARD_ENDIANNESS) {
+        return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    }
+    // If endianness doesn't match, we need to swap byte order
+    const result = new Uint8Array(array.length * 2);
+    const view = new DataView(result.buffer);
+    for (let i = 0; i < array.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        view.setUint16(i * 2, array[i], STANDARD_ENDIANNESS);
+    }
+    return result;
+};
+const bytesToUint16Array = (bytes) => {
+    if (bytes.byteLength % 2 !== 0) {
+        throw new Error('Byte array length must be a multiple of 2 to convert to Uint16Array');
+    }
+    // If system endianness matches our standard, we can create a view directly
+    if (isLittleEndian === STANDARD_ENDIANNESS) {
+        return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+    }
+    // If endianness doesn't match, we need to swap byte order
+    const result = new Uint16Array(bytes.byteLength / 2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let i = 0; i < result.length; i++) {
+        result[i] = view.getUint16(i * 2, STANDARD_ENDIANNESS);
+    }
+    return result;
+};
+const serializeStopsAdjacency = (stopsAdjacency) => {
+    const protoStopsAdjacency = {
+        stops: {},
+    };
+    stopsAdjacency.forEach((value, key) => {
+        protoStopsAdjacency.stops[key] = {
+            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
+                minTransferTime: transfer.minTransferTime.toSeconds(),
+            })))),
+            routes: value.routes,
+        };
+    });
+    return protoStopsAdjacency;
+};
+const serializeRoutesAdjacency = (routesAdjacency) => {
+    const protoRoutesAdjacency = {
+        routes: {},
+    };
+    routesAdjacency.forEach((route, key) => {
+        const routeData = route.serialize();
+        protoRoutesAdjacency.routes[key] = {
+            stopTimes: uint16ArrayToBytes(routeData.stopTimes),
+            pickUpDropOffTypes: routeData.pickUpDropOffTypes,
+            stops: uint32ArrayToBytes(routeData.stops),
+            serviceRouteId: routeData.serviceRouteId,
+        };
+    });
+    return protoRoutesAdjacency;
+};
+const serializeServiceRoutesMap = (serviceRoutesMap) => {
+    const protoServiceRoutesMap = {
+        routes: {},
+    };
+    serviceRoutesMap.forEach((value, key) => {
+        protoServiceRoutesMap.routes[key] = {
+            type: serializeRouteType(value.type),
+            name: value.name,
+        };
+    });
+    return protoServiceRoutesMap;
+};
+const deserializeStopsAdjacency = (protoStopsAdjacency) => {
+    const stopsAdjacency = new Map();
+    Object.entries(protoStopsAdjacency.stops).forEach(([keyStr, value]) => {
+        const key = parseInt(keyStr, 10);
+        stopsAdjacency.set(key, {
+            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: parseTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
+                minTransferTime: Duration.fromSeconds(transfer.minTransferTime),
+            })))),
+            routes: value.routes,
+        });
+    });
+    return stopsAdjacency;
+};
+const deserializeRoutesAdjacency = (protoRoutesAdjacency) => {
+    const routesAdjacency = new Map();
+    Object.entries(protoRoutesAdjacency.routes).forEach(([key, value]) => {
+        const stops = bytesToUint32Array(value.stops);
+        routesAdjacency.set(key, new Route$1(bytesToUint16Array(value.stopTimes), value.pickUpDropOffTypes, stops, value.serviceRouteId));
+    });
+    return routesAdjacency;
+};
+const deserializeServiceRoutesMap = (protoServiceRoutesMap) => {
+    const serviceRoutesMap = new Map();
+    Object.entries(protoServiceRoutesMap.routes).forEach(([key, value]) => {
+        serviceRoutesMap.set(key, {
+            type: parseRouteType(value.type),
+            name: value.name,
+        });
+    });
+    return serviceRoutesMap;
+};
+const parseTransferType = (type) => {
+    switch (type) {
+        case TransferType.RECOMMENDED_TRANSFER_POINT:
+            return 'RECOMMENDED';
+        case TransferType.TIMED_TRANSFER:
+            return 'GUARANTEED';
+        case TransferType.REQUIRES_MINIMAL_TIME:
+            return 'REQUIRES_MINIMAL_TIME';
+        case TransferType.IN_SEAT_TRANSFER:
+            return 'IN_SEAT';
+        case TransferType.UNRECOGNIZED:
+            throw new Error('Unrecognized protobuf transfer type.');
+    }
+};
+const serializeTransferType = (type) => {
+    switch (type) {
+        case 'RECOMMENDED':
+            return TransferType.RECOMMENDED_TRANSFER_POINT;
+        case 'GUARANTEED':
+            return TransferType.TIMED_TRANSFER;
+        case 'REQUIRES_MINIMAL_TIME':
+            return TransferType.REQUIRES_MINIMAL_TIME;
+        case 'IN_SEAT':
+            return TransferType.IN_SEAT_TRANSFER;
+    }
+};
+const parseRouteType = (type) => {
+    switch (type) {
+        case RouteType.TRAM:
+            return 'TRAM';
+        case RouteType.SUBWAY:
+            return 'SUBWAY';
+        case RouteType.RAIL:
+            return 'RAIL';
+        case RouteType.BUS:
+            return 'BUS';
+        case RouteType.FERRY:
+            return 'FERRY';
+        case RouteType.CABLE_TRAM:
+            return 'CABLE_TRAM';
+        case RouteType.AERIAL_LIFT:
+            return 'AERIAL_LIFT';
+        case RouteType.FUNICULAR:
+            return 'FUNICULAR';
+        case RouteType.TROLLEYBUS:
+            return 'TROLLEYBUS';
+        case RouteType.MONORAIL:
+            return 'MONORAIL';
+        case RouteType.UNRECOGNIZED:
+        default:
+            throw new Error('Unrecognized protobuf route type.');
+    }
+};
+const serializeRouteType = (type) => {
+    switch (type) {
+        case 'TRAM':
+            return RouteType.TRAM;
+        case 'SUBWAY':
+            return RouteType.SUBWAY;
+        case 'RAIL':
+            return RouteType.RAIL;
+        case 'BUS':
+            return RouteType.BUS;
+        case 'FERRY':
+            return RouteType.FERRY;
+        case 'CABLE_TRAM':
+            return RouteType.CABLE_TRAM;
+        case 'AERIAL_LIFT':
+            return RouteType.AERIAL_LIFT;
+        case 'FUNICULAR':
+            return RouteType.FUNICULAR;
+        case 'TROLLEYBUS':
+            return RouteType.TROLLEYBUS;
+        case 'MONORAIL':
+            return RouteType.MONORAIL;
+    }
+};
+
+const ALL_TRANSPORT_MODES = new Set([
     'TRAM',
     'SUBWAY',
     'RAIL',
@@ -17144,11 +18074,10 @@ const ALL_TRANSPORT_MODES = [
     'FUNICULAR',
     'TROLLEYBUS',
     'MONORAIL',
-];
+]);
 const CURRENT_VERSION = '0.0.3';
 /**
- * The internal transit timetable format
- * reuses some GTFS concepts for the sake of simplicity for now.
+ * The internal transit timetable format.
  */
 class Timetable {
     constructor(stopsAdjacency, routesAdjacency, routes) {
@@ -17157,9 +18086,9 @@ class Timetable {
         this.routes = routes;
     }
     /**
-     * Serializes the Timetable into a binary protobuf.
+     * Serializes the Timetable into a binary array.
      *
-     * @returns {Uint8Array} - The serialized binary data.
+     * @returns The serialized binary data.
      */
     serialize() {
         const protoTimetable = {
@@ -17175,8 +18104,8 @@ class Timetable {
     /**
      * Deserializes a binary protobuf into a Timetable object.
      *
-     * @param {Uint8Array} data - The binary data to deserialize.
-     * @returns {Timetable} - The deserialized Timetable object.
+     * @param data - The binary data to deserialize.
+     * @returns The deserialized Timetable object.
      */
     static fromData(data) {
         const reader = new BinaryReader(data);
@@ -17192,108 +18121,89 @@ class Timetable {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         deserializeServiceRoutesMap(protoTimetable.routes));
     }
-    getRoutesThroughStop(stopId) {
-        const stopAdjacency = this.stopsAdjacency.get(stopId);
-        if (!stopAdjacency) {
-            return [];
-        }
-        return stopAdjacency.routes;
-    }
+    /**
+     * Retrieves the route associated with the given route ID.
+     *
+     * @param routeId - The ID of the route to be retrieved.
+     * @returns The route corresponding to the provided ID,
+     * or undefined if no such route exists.
+     */
     getRoute(routeId) {
         return this.routesAdjacency.get(routeId);
     }
+    /**
+     * Retrieves all transfer options available at the specified stop.
+     *
+     * @param stopId - The ID of the stop to get transfers for.
+     * @returns An array of transfer options available at the stop.
+     */
     getTransfers(stopId) {
         var _a, _b;
-        return (_b = (_a = this.stopsAdjacency.get(stopId)) === null || _a === undefined ? undefined : _a.transfers) !== null && _b !== undefined ? _b : [];
+        return (_b = (_a = this.stopsAdjacency.get(stopId)) === null || _a === void 0 ? void 0 : _a.transfers) !== null && _b !== void 0 ? _b : [];
+    }
+    /**
+     * Retrieves the service route associated with the given route.
+     * A service route refers to a collection of trips that are displayed
+     * to riders as a single service.
+     *
+     * @param route - The route for which the service route is to be retrieved.
+     * @returns The service route corresponding to the provided route.
+     */
+    getServiceRoute(route) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.routes.get(route.serviceRoute());
+    }
+    /**
+     * Finds all routes passing through a stop.
+     *
+     * @param stopId - The ID of the stop to find routes for.
+     * @returns An array of routes passing through the specified stop.
+     */
+    routesPassingThrough(stopId) {
+        const stopData = this.stopsAdjacency.get(stopId);
+        if (!stopData) {
+            return [];
+        }
+        const routes = [];
+        for (const routeId of stopData.routes) {
+            const route = this.routesAdjacency.get(routeId);
+            if (route) {
+                routes.push(route);
+            }
+        }
+        return routes;
     }
     /**
      * Finds routes that are reachable from a set of stop IDs.
      * Also identifies the first stop available to hop on each route among
      * the input stops.
+     *
+     * @param fromStops - The set of stop IDs to find reachable routes from.
+     * @param transportModes - The set of transport modes to consider for reachable routes.
+     * @returns A map of reachable routes to the first stop available to hop on each route.
      */
-    /* eslint-disable @typescript-eslint/no-non-null-assertion */
     findReachableRoutes(fromStops, transportModes = ALL_TRANSPORT_MODES) {
-        var _a;
         const reachableRoutes = new Map();
-        for (const stop of fromStops) {
-            const validRoutes = (_a = this.stopsAdjacency
-                .get(stop)) === null || _a === undefined ? undefined : _a.routes.filter((routeId) => {
-                const serviceRoute = this.getServiceRouteFromRouteId(routeId);
-                if (!serviceRoute) {
-                    return false;
-                }
-                return transportModes.includes(serviceRoute.type);
+        for (const originStop of fromStops) {
+            const validRoutes = this.routesPassingThrough(originStop).filter((route) => {
+                const serviceRoute = this.getServiceRoute(route);
+                return transportModes.has(serviceRoute.type);
             });
-            for (const routeId of validRoutes || []) {
-                const hopOnStop = reachableRoutes.get(routeId);
+            for (const route of validRoutes) {
+                const hopOnStop = reachableRoutes.get(route);
                 if (hopOnStop) {
-                    // Checks if the existing hop on stop is before the current stop
-                    const routeStopIndices = this.routesAdjacency.get(routeId).stopIndices;
-                    const stopIndex = routeStopIndices.get(stop);
-                    const hopOnStopIndex = routeStopIndices.get(hopOnStop);
-                    if (stopIndex < hopOnStopIndex) {
+                    if (route.isBefore(originStop, hopOnStop)) {
                         // if the current stop is before the existing hop on stop, replace it
-                        reachableRoutes.set(routeId, stop);
+                        reachableRoutes.set(route, originStop);
                     }
                 }
                 else {
-                    reachableRoutes.set(routeId, stop);
+                    reachableRoutes.set(route, originStop);
                 }
             }
         }
         return reachableRoutes;
     }
-    getServiceRouteFromRouteId(routeId) {
-        const route = this.routesAdjacency.get(routeId);
-        if (!route) {
-            console.warn(`Route ${routeId} not found.`);
-            return undefined;
-        }
-        return this.routes.get(route.serviceRouteId);
-    }
-    getServiceRoute(serviceRouteId) {
-        return this.routes.get(serviceRouteId);
-    }
-    /**
-     * Finds the earliest trip that can be taken from a specific stop on a given route,
-     * optionally constrained by a latest trip index and a time before which the trip
-     * should not depart.
-     */
-    findEarliestTrip(route, stopId, beforeTrip, after = Time.origin()) {
-        const stopIndex = route.stopIndices.get(stopId);
-        const stopsNumber = route.stops.length;
-        if (beforeTrip === undefined) {
-            for (let tripIndex = 0; tripIndex < route.stopTimes.length / stopsNumber; tripIndex++) {
-                const stopTimeIndex = tripIndex * stopsNumber + stopIndex;
-                const departure = route.stopTimes[stopTimeIndex * 2 + 1];
-                const pickUpType = route.pickUpDropOffTypes[stopTimeIndex * 2];
-                if (departure >= after.toMinutes() && pickUpType !== NOT_AVAILABLE) {
-                    return tripIndex;
-                }
-            }
-            return undefined;
-        }
-        else {
-            let earliestTripIndex;
-            let earliestDeparture;
-            for (let tripIndex = beforeTrip; // ?? route.stopTimes.length / stopsNumber - 1;
-             tripIndex >= 0; tripIndex--) {
-                const stopTimeIndex = tripIndex * stopsNumber + stopIndex;
-                const departure = route.stopTimes[stopTimeIndex * 2 + 1];
-                const pickUpType = route.pickUpDropOffTypes[stopTimeIndex * 2];
-                if (departure < after.toMinutes()) {
-                    break;
-                }
-                if (pickUpType !== NOT_AVAILABLE &&
-                    (earliestDeparture === undefined ||
-                        departure < earliestDeparture.toMinutes())) {
-                    earliestTripIndex = tripIndex;
-                    earliestDeparture = Time.fromMinutes(departure);
-                }
-            }
-            return earliestTripIndex;
-        }
-    }
 }
 
 const standardProfile = {
@@ -17610,7 +18520,7 @@ const normalize_options = function (opts) {
     );
   }
   // Normalize option `columns`
-  options.cast_first_line_to_header = null;
+  options.cast_first_line_to_header = undefined;
   if (options.columns === true) {
     // Fields in the first line are converted as-is to columns
     options.cast_first_line_to_header = undefined;
@@ -18142,7 +19052,7 @@ const normalize_options = function (opts) {
   // Normalize option `to`
   if (options.to === undefined || options.to === null) {
     options.to = -1;
-  } else {
+  } else if (options.to !== -1) {
     if (typeof options.to === "string" && /\d+/.test(options.to)) {
       options.to = parseInt(options.to);
     }
@@ -18161,7 +19071,7 @@ const normalize_options = function (opts) {
   // Normalize option `to_line`
   if (options.to_line === undefined || options.to_line === null) {
     options.to_line = -1;
-  } else {
+  } else if (options.to_line !== -1) {
     if (typeof options.to_line === "string" && /\d+/.test(options.to_line)) {
       options.to_line = parseInt(options.to_line);
     }
@@ -18292,10 +19202,14 @@ const transform = function (original_options = {}) {
               this.state.bufBytesStart += bomLength;
               buf = buf.slice(bomLength);
               // Renormalize original options with the new encoding
-              this.options = normalize_options({
+              const options = normalize_options({
                 ...this.original_options,
                 encoding: encoding,
               });
+              // Properties are merged with the existing options instance
+              for (const key in options) {
+                this.options[key] = options[key];
+              }
               // Options will re-evaluate the Buffer with the new encoding
               ({ comment, escape, quote } = this.options);
               break;
@@ -19038,10 +19952,14 @@ const transform = function (original_options = {}) {
       if (skip_records_with_error) {
         this.state.recordHasError = true;
         if (this.options.on_skip !== undefined) {
-          this.options.on_skip(
-            err,
-            raw ? this.state.rawBuffer.toString(encoding) : undefined,
-          );
+          try {
+            this.options.on_skip(
+              err,
+              raw ? this.state.rawBuffer.toString(encoding) : undefined,
+            );
+          } catch (err) {
+            return err;
+          }
         }
         // this.emit('skip', err, raw ? this.state.rawBuffer.toString(encoding) : undefined);
         return undefined;
@@ -19238,11 +20156,17 @@ const hashIds = (ids) => {
  * @param stream The CSV stream.
  * @returns A parser from the csv-parse library.
  */
-const parseCsv = (stream) => {
+const parseCsv = (stream, numericColumns = []) => {
     return stream.pipe(parse({
         delimiter: ',',
         columns: true,
-        cast: true,
+        cast: (value, context) => {
+            if (typeof context.column === 'string' &&
+                numericColumns.includes(context.column)) {
+                return Number(value);
+            }
+            return value;
+        },
         bom: true,
         ignore_last_delimiters: true,
         relax_column_count: true,
@@ -19256,11 +20180,11 @@ const parseCsv = (stream) => {
  * @param profile A configuration object defining the specificities of the GTFS feed.
  * @returns A map of all the valid routes.
  */
-const parseRoutes = (routesStream_1, ...args_1) => __awaiter(undefined, [routesStream_1, ...args_1], undefined, function* (routesStream, profile = standardProfile) {
+const parseRoutes = (routesStream_1, ...args_1) => __awaiter(void 0, [routesStream_1, ...args_1], void 0, function* (routesStream, profile = standardProfile) {
     var _a, e_1, _b, _c;
     const routes = new Map();
     try {
-        for (var _d = true, _e = __asyncValues(parseCsv(routesStream)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+        for (var _d = true, _e = __asyncValues(parseCsv(routesStream, ['route_type'])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
             _c = _f.value;
             _d = false;
             const rawLine = _c;
@@ -19271,7 +20195,7 @@ const parseRoutes = (routesStream_1, ...args_1) => __awaiter(undefined, [routesS
                 continue;
             }
             routes.set(line.route_id, {
-                name: line.route_short_name + '',
+                name: line.route_short_name,
                 type: routeType,
             });
         }
@@ -19324,13 +20248,23 @@ const weekdays = {
  * @param date The active date.
  * @param calendarStream A readable stream for the GTFS calendar.txt file.
  */
-const parseCalendar = (calendarStream, serviceIds, date) => __awaiter(undefined, undefined, undefined, function* () {
+const parseCalendar = (calendarStream, serviceIds, date) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
     const activeDate = toGtfsDate(date);
     const weekday = date.weekday;
     const weekdayIndex = weekdays[weekday];
     try {
-        for (var _d = true, _e = __asyncValues(parseCsv(calendarStream)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+        for (var _d = true, _e = __asyncValues(parseCsv(calendarStream, [
+            'monday',
+            'tuesday',
+            'wednesday',
+            'thursday',
+            'friday',
+            'saturday',
+            'sunday',
+            'start_date',
+            'end_date',
+        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
             _c = _f.value;
             _d = false;
             const rawLine = _c;
@@ -19361,11 +20295,14 @@ const parseCalendar = (calendarStream, serviceIds, date) => __awaiter(undefined,
  * @param date The active date, in the format "YYYYMMDD".
  * @param calendarDatesStream A readable stream for the GTFS calendar_dates.txt file.
  */
-const parseCalendarDates = (calendarDatesStream, serviceIds, date) => __awaiter(undefined, undefined, undefined, function* () {
+const parseCalendarDates = (calendarDatesStream, serviceIds, date) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_2, _b, _c;
     const activeDate = toGtfsDate(date);
     try {
-        for (var _d = true, _e = __asyncValues(parseCsv(calendarDatesStream)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+        for (var _d = true, _e = __asyncValues(parseCsv(calendarDatesStream, [
+            'date',
+            'exception_type',
+        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
             _c = _f.value;
             _d = false;
             const rawLine = _c;
@@ -19398,17 +20335,21 @@ const parseCalendarDates = (calendarDatesStream, serviceIds, date) => __awaiter(
  * @param stopsStream The readable stream containing the stops data.
  * @return A mapping of stop IDs to corresponding stop details.
  */
-const parseStops = (stopsStream, platformParser) => __awaiter(undefined, undefined, undefined, function* () {
+const parseStops = (stopsStream, platformParser) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
     const parsedStops = new Map();
     let i = 0;
     try {
-        for (var _d = true, _e = __asyncValues(parseCsv(stopsStream)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+        for (var _d = true, _e = __asyncValues(parseCsv(stopsStream, [
+            'stop_lat',
+            'stop_lon',
+            'location_type',
+        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
             _c = _f.value;
             _d = false;
             const rawLine = _c;
             const line = rawLine;
-            const stop = Object.assign({ id: i, sourceStopId: line.stop_id + '', name: line.stop_name, lat: line.stop_lat, lon: line.stop_lon, locationType: line.location_type
+            const stop = Object.assign({ id: i, sourceStopId: line.stop_id, name: line.stop_name, lat: line.stop_lat, lon: line.stop_lon, locationType: line.location_type
                     ? parseGtfsLocationType(line.location_type)
                     : 'SIMPLE_STOP_OR_PLATFORM', children: [] }, (line.parent_station && { parentSourceId: line.parent_station }));
             if (platformParser) {
@@ -19422,7 +20363,7 @@ const parseStops = (stopsStream, platformParser) => __awaiter(undefined, undefin
                     console.info(`Could not parse platform for stop ${line.stop_id}.`);
                 }
             }
-            parsedStops.set(line.stop_id + '', stop);
+            parsedStops.set(line.stop_id, stop);
             i = i + 1;
         }
     }
@@ -19499,11 +20440,14 @@ const parseGtfsLocationType = (gtfsLocationType) => {
  * @param stopsStream The readable stream containing the stops data.
  * @return A mapping of stop IDs to corresponding stop details.
  */
-const parseTransfers = (transfersStream, stopsMap) => __awaiter(undefined, undefined, undefined, function* () {
+const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
     const transfers = new Map();
     try {
-        for (var _d = true, _e = __asyncValues(parseCsv(transfersStream)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+        for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
+            'transfer_type',
+            'min_transfer_time',
+        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
             _c = _f.value;
             _d = false;
             const rawLine = _c;
@@ -19528,9 +20472,9 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(undefined, undef
                 console.info(`Missing minimum transfer time between ${transferEntry.from_stop_id} and ${transferEntry.to_stop_id}.`);
             }
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const fromStop = stopsMap.get(transferEntry.from_stop_id + '');
+            const fromStop = stopsMap.get(transferEntry.from_stop_id);
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const toStop = stopsMap.get(transferEntry.to_stop_id + '');
+            const toStop = stopsMap.get(transferEntry.to_stop_id);
             const transfer = Object.assign({ destination: toStop.id, type: parseGtfsTransferType(transferEntry.transfer_type) }, (transferEntry.min_transfer_time && {
                 minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
             }));
@@ -19570,11 +20514,11 @@ const parseGtfsTransferType = (gtfsTransferType) => {
  * @param routeIds A mapping of route IDs to route details.
  * @returns A mapping of trip IDs to corresponding route IDs.
  */
-const parseTrips = (tripsStream, serviceIds, routeIds) => __awaiter(undefined, undefined, undefined, function* () {
+const parseTrips = (tripsStream, serviceIds, routeIds) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
     const trips = new Map();
     try {
-        for (var _d = true, _e = __asyncValues(parseCsv(tripsStream)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+        for (var _d = true, _e = __asyncValues(parseCsv(tripsStream, ['stop_sequence'])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
             _c = _f.value;
             _d = false;
             const rawLine = _c;
@@ -19604,11 +20548,14 @@ const buildStopsAdjacencyStructure = (validStops, routes, transfersMap) => {
     const stopsAdjacency = new Map();
     for (const routeId of routes.keys()) {
         const route = routes.get(routeId);
-        for (const stop of route.stops) {
+        if (!route) {
+            throw new Error(`Route ${routeId} not found`);
+        }
+        for (const stop of route.stopsIterator()) {
             if (!stopsAdjacency.get(stop) && validStops.has(stop)) {
                 stopsAdjacency.set(stop, { routes: [], transfers: [] });
             }
-            (_a = stopsAdjacency.get(stop)) === null || _a === undefined ? undefined : _a.routes.push(routeId);
+            (_a = stopsAdjacency.get(stop)) === null || _a === void 0 ? void 0 : _a.routes.push(routeId);
         }
     }
     for (const [stop, transfers] of transfersMap) {
@@ -19632,7 +20579,7 @@ const buildStopsAdjacencyStructure = (validStops, routes, transfersMap) => {
  * @param validStopIds A set of valid stop IDs.
  * @returns A mapping of route IDs to route details. The routes returned correspond to the set of trips from GTFS that share the same stop list.
  */
-const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) => __awaiter(undefined, undefined, undefined, function* () {
+const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_2, _b, _c;
     var _d, _e;
     /**
@@ -19670,7 +20617,6 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
             route = {
                 serviceRouteId: gtfsRouteId,
                 stops: stopsArray,
-                stopIndices: new Map(stops.map((stop, i) => [stop, i])),
                 stopTimes: stopTimesArray,
                 pickUpDropOffTypes: pickUpDropOffTypesArray,
             };
@@ -19735,7 +20681,7 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
     let dropOffTypes = [];
     let currentTripId = undefined;
     try {
-        for (var _f = true, _g = __asyncValues(parseCsv(stopTimesStream)), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+        for (var _f = true, _g = __asyncValues(parseCsv(stopTimesStream, ['stop_sequence'])), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
             _c = _h.value;
             _f = false;
             const rawLine = _c;
@@ -19756,7 +20702,7 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
             }
             currentTripId = line.trip_id;
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            stops.push(stopsMap.get(line.stop_id + '').id);
+            stops.push(stopsMap.get(line.stop_id).id);
             const departure = (_d = line.departure_time) !== null && _d !== void 0 ? _d : line.arrival_time;
             const arrival = (_e = line.arrival_time) !== null && _e !== void 0 ? _e : line.departure_time;
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -19778,12 +20724,15 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
     if (currentTripId) {
         addTrip(currentTripId);
     }
-    return routes;
+    const routesAdjacency = new Map();
+    for (const [routeId, routeData] of routes) {
+        routesAdjacency.set(routeId, new Route$1(routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
+    }
+    return routesAdjacency;
 });
 const parsePickupDropOffType = (gtfsType) => {
     switch (gtfsType) {
         default:
-            console.warn(`Unknown pickup/drop-off type ${gtfsType}`);
             return REGULAR;
         case 0:
             return REGULAR;
@@ -19818,7 +20767,7 @@ class GtfsParser {
      * @returns An object containing the timetable and stops map.
      */
     parse(date) {
-        return __awaiter(this, undefined, undefined, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
             const zip = new StreamZip.async({ file: this.path });
             const entries = yield zip.entries();
             const datetime = DateTime.fromJSDate(date);
@@ -19879,7 +20828,7 @@ class GtfsParser {
      * @returns An object containing the timetable and stops map.
      */
     parseStops() {
-        return __awaiter(this, undefined, undefined, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
             const zip = new StreamZip.async({ file: this.path });
             log.info(`Parsing ${STOPS_FILE}`);
             const stopsStream = yield zip.stream(STOPS_FILE);
@@ -19897,7 +20846,7 @@ class GtfsParser {
  * @returns The platform corresponding to this stop.
  */
 const platformParser = (stopEntry) => {
-    const stopId = String(stopEntry.stop_id);
+    const stopId = stopEntry.stop_id;
     const stopParts = stopId.split(':');
     if (stopParts.length > 2) {
         return stopParts[2];
@@ -20018,7 +20967,7 @@ class Query {
 }
 Query.Builder = class {
     constructor() {
-        this.toValue = [];
+        this.toValue = new Set();
         // lastDepartureTimeValue?: Date;
         // via: StopId[] = [];
         this.optionsValue = {
@@ -20027,26 +20976,47 @@ Query.Builder = class {
             transportModes: ALL_TRANSPORT_MODES,
         };
     }
+    /**
+     * Sets the starting stop.
+     */
     from(from) {
         this.fromValue = from;
         return this;
     }
+    /**
+     * Sets the destination stops(s), routing will stop when all the provided stops are reached.
+     */
     to(to) {
-        this.toValue = Array.isArray(to) ? to : [to];
+        this.toValue = to instanceof Set ? to : new Set([to]);
         return this;
     }
+    /**
+     * Sets the departure time for the query.
+     * Note that the router will favor routes that depart shortly after the provided departure time,
+     * even if a later route might arrive at the same time.
+     * Range queries will allow to specify a range of departure times in the future.
+     */
     departureTime(departureTime) {
         this.departureTimeValue = departureTime;
         return this;
     }
+    /**
+     * Sets the maximum number of transfers allowed.
+     */
     maxTransfers(maxTransfers) {
         this.optionsValue.maxTransfers = maxTransfers;
         return this;
     }
+    /**
+     * Sets the minimum transfer time to use when no transfer time is provided in the data.
+     */
     minTransferTime(minTransferTime) {
         this.optionsValue.minTransferTime = minTransferTime;
         return this;
     }
+    /**
+     * Sets the transport modes to consider.
+     */
     transportModes(transportModes) {
         this.optionsValue.transportModes = transportModes;
         return this;
@@ -20056,10 +21026,20 @@ Query.Builder = class {
     }
 };
 
+/**
+ * Represents a resolved route consisting of multiple legs,
+ * which can be either vehicle legs or transfer legs.
+ */
 class Route {
     constructor(legs) {
         this.legs = legs;
     }
+    /**
+     * Calculates the departure time of the route.
+     *
+     * @returns The departure time of the route.
+     * @throws If no vehicle leg is found in the route.
+     */
     departureTime() {
         const cumulativeTransferTime = Duration.zero();
         for (let i = 0; i < this.legs.length; i++) {
@@ -20074,6 +21054,12 @@ class Route {
         }
         throw new Error('No vehicle leg found in route');
     }
+    /**
+     * Calculates the arrival time of the route.
+     *
+     * @returns The arrival time of the route.
+     * @throws If no vehicle leg is found in the route.
+     */
     arrivalTime() {
         let lastVehicleArrivalTime = Time.origin();
         const totalTransferTime = Duration.zero();
@@ -20096,25 +21082,71 @@ class Route {
         }
         return lastVehicleArrivalTime.plus(totalTransferTime);
     }
+    /**
+     * Calculates the total duration of the route.
+     *
+     * @returns The total duration of the route.
+     */
     totalDuration() {
         if (this.legs.length === 0)
             return Duration.zero();
         return this.arrivalTime().diff(this.departureTime());
     }
-    print() {
+    /**
+     * Generates a human-readable string representation of the route.
+     *
+     * @returns A formatted string describing each leg of the route.
+     */
+    toString() {
         return this.legs
             .map((leg, index) => {
-            var _a, _b;
-            if ('route' in leg) {
-                return `Leg ${index + 1}: ${leg.from.name} to ${leg.to.name}
-            via route ${leg.route.type} ${leg.route.name},
-            departs at ${leg.departureTime.toString()}, arrives at ${leg.arrivalTime.toString()}`;
-            }
-            return `Leg ${index + 1}: Transfer from ${leg.from.name} to ${leg.to.name},
-            minimum transfer time: ${(_b = (_a = leg.minTransferTime) === null || _a === undefined ? undefined : _a.toString()) !== null && _b !== undefined ? _b : 'not specified'}`;
+            var _a;
+            const fromStop = `From: ${leg.from.name}${leg.from.platform ? ` (Pl. ${leg.from.platform})` : ''}`;
+            const toStop = `To: ${leg.to.name}${leg.to.platform ? ` (Pl. ${leg.to.platform})` : ''}`;
+            const transferDetails = 'minTransferTime' in leg
+                ? `Minimum Transfer Time: ${(_a = leg.minTransferTime) === null || _a === void 0 ? void 0 : _a.toString()}`
+                : '';
+            const travelDetails = 'route' in leg && 'departureTime' in leg && 'arrivalTime' in leg
+                ? `Route: ${leg.route.type} ${leg.route.name}, Departure: ${leg.departureTime.toString()}, Arrival: ${leg.arrivalTime.toString()}`
+                : '';
+            return [
+                `Leg ${index + 1}:`,
+                `  ${fromStop}`,
+                `  ${toStop}`,
+                transferDetails ? `  ${transferDetails}` : '',
+                travelDetails ? `  ${travelDetails}` : '',
+            ]
+                .filter((line) => line.trim() !== '')
+                .join('\n');
         })
             .join('\n');
     }
+    /**
+     * Generates a concise JSON representation of the route.
+     * This is particularly useful for generating regression tests
+     * to verify the correctness of route calculations.
+     *
+     * @returns A JSON representation of the route.
+     */
+    asJson() {
+        const jsonLegs = this.legs.map((leg) => {
+            if ('route' in leg) {
+                return {
+                    from: leg.from.sourceStopId,
+                    to: leg.to.sourceStopId,
+                    departure: leg.departureTime.toString(),
+                    arrival: leg.arrivalTime.toString(),
+                    route: leg.route,
+                };
+            }
+            else {
+                return Object.assign({ from: leg.from.sourceStopId, to: leg.to.sourceStopId, type: leg.type }, (leg.minTransferTime !== undefined && {
+                    minTransferTime: leg.minTransferTime.toString(),
+                }));
+            }
+        });
+        return jsonLegs;
+    }
 }
 
 class Result {
@@ -20133,7 +21165,11 @@ class Result {
      */
     bestRoute(to) {
         var _a, _b, _c;
-        const destinationList = Array.isArray(to) ? to : to ? [to] : this.query.to;
+        const destinationList = to instanceof Set
+            ? Array.from(to)
+            : to
+                ? [to]
+                : Array.from(this.query.to);
         const destinations = destinationList.flatMap((destination) => this.stopsIndex.equivalentStops(destination));
         let fastestDestination = undefined;
         let fastestTime = undefined;
@@ -20141,7 +21177,7 @@ class Result {
             const arrivalTime = this.earliestArrivals.get(destination.id);
             if (arrivalTime !== undefined) {
                 if (fastestTime === undefined ||
-                    arrivalTime.time.toMinutes() < fastestTime.time.toMinutes()) {
+                    arrivalTime.arrival.isBefore(fastestTime.arrival)) {
                     fastestDestination = destination.id;
                     fastestTime = arrivalTime;
                 }
@@ -20154,9 +21190,9 @@ class Result {
         let currentStop = fastestDestination;
         let round = fastestTime.legNumber;
         while (fastestTime.origin !== currentStop) {
-            const tripLeg = (_a = this.earliestArrivalsPerRound[round]) === null || _a === undefined ? undefined : _a.get(currentStop);
-            if (!(tripLeg === null || tripLeg === undefined ? undefined : tripLeg.leg)) {
-                throw new Error(`No leg found for a trip leg: start stop=${(_c = (_b = tripLeg === null || tripLeg === undefined ? undefined : tripLeg.leg) === null || _b === undefined ? undefined : _b.from.id) !== null && _c !== undefined ? _c : 'unknown'}, end stop=${currentStop}, round=${round}, origin=${fastestTime.origin}`);
+            const tripLeg = (_a = this.earliestArrivalsPerRound[round]) === null || _a === void 0 ? void 0 : _a.get(currentStop);
+            if (!(tripLeg === null || tripLeg === void 0 ? void 0 : tripLeg.leg)) {
+                throw new Error(`No leg found for a trip leg: start stop=${(_c = (_b = tripLeg === null || tripLeg === void 0 ? void 0 : tripLeg.leg) === null || _b === void 0 ? void 0 : _b.from.id) !== null && _c !== void 0 ? _c : 'unknown'}, end stop=${currentStop}, round=${round}, origin=${fastestTime.origin}`);
             }
             route.unshift(tripLeg.leg);
             currentStop = tripLeg.leg.from.id;
@@ -20178,13 +21214,13 @@ class Result {
         let earliestArrival = undefined;
         const relevantArrivals = maxTransfers !== undefined
             ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.earliestArrivalsPerRound[maxTransfers - 1]
+                this.earliestArrivalsPerRound[maxTransfers + 1]
             : this.earliestArrivals;
         for (const equivalentStop of equivalentStops) {
             const arrivalTime = relevantArrivals.get(equivalentStop.id);
             if (arrivalTime !== undefined) {
                 if (earliestArrival === undefined ||
-                    arrivalTime.time.toMinutes() < earliestArrival.time.toMinutes()) {
+                    arrivalTime.arrival.isBefore(earliestArrival.arrival)) {
                     earliestArrival = arrivalTime;
                 }
             }
@@ -20194,6 +21230,12 @@ class Result {
 }
 
 const UNREACHED = Time.infinity();
+/**
+ * A public transportation network router utilizing the RAPTOR algorithm for
+ * efficient journey planning and routing. For more information on the RAPTOR
+ * algorithm, refer to its detailed explanation in the research paper:
+ * https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
+ */
 class Router {
     constructor(timetable, stopsIndex) {
         this.timetable = timetable;
@@ -20205,10 +21247,18 @@ class Router {
      * stops that can be reached through these transfers.
      */
     considerTransfers(query, markedStops, arrivalsAtCurrentRound, earliestArrivals, round) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         const { options } = query;
         const newlyMarkedStops = new Set();
         for (const stop of markedStops) {
+            const currentArrival = arrivalsAtCurrentRound.get(stop);
+            if (!currentArrival)
+                continue;
+            // Skip transfers if the last leg was also a transfer
+            const previousLeg = currentArrival.leg;
+            if (previousLeg && !('route' in previousLeg)) {
+                continue;
+            }
             for (const transfer of this.timetable.getTransfers(stop)) {
                 let transferTime;
                 if (transfer.minTransferTime) {
@@ -20220,14 +21270,12 @@ class Router {
                 else {
                     transferTime = options.minTransferTime;
                 }
-                const arrivalAfterTransfer = arrivalsAtCurrentRound
-                    .get(stop)
-                    .time.plus(transferTime);
-                const originalArrival = (_b = (_a = arrivalsAtCurrentRound.get(transfer.destination)) === null || _a === undefined ? undefined : _a.time) !== null && _b !== undefined ? _b : UNREACHED;
-                if (arrivalAfterTransfer.toMinutes() < originalArrival.toMinutes()) {
-                    const origin = (_d = (_c = arrivalsAtCurrentRound.get(stop)) === null || _c === undefined ? undefined : _c.origin) !== null && _d !== undefined ? _d : stop;
+                const arrivalAfterTransfer = currentArrival.arrival.plus(transferTime);
+                const originalArrival = (_b = (_a = arrivalsAtCurrentRound.get(transfer.destination)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+                if (arrivalAfterTransfer.isBefore(originalArrival)) {
+                    const origin = currentArrival.origin;
                     arrivalsAtCurrentRound.set(transfer.destination, {
-                        time: arrivalAfterTransfer,
+                        arrival: arrivalAfterTransfer,
                         legNumber: round,
                         origin: origin,
                         leg: {
@@ -20238,7 +21286,7 @@ class Router {
                         },
                     });
                     earliestArrivals.set(transfer.destination, {
-                        time: arrivalAfterTransfer,
+                        arrival: arrivalAfterTransfer,
                         legNumber: round,
                         origin: origin,
                     });
@@ -20250,6 +21298,22 @@ class Router {
             markedStops.add(newStop);
         }
     }
+    /**
+     * Finds the earliest arrival time at any stop from a given set of destinations.
+     *
+     * @param earliestArrivals A map of stops to their earliest reaching times.
+     * @param destinations An array of destination stops to evaluate.
+     * @returns The earliest arrival time among the provided destinations.
+     */
+    earliestArrivalAtAnyStop(earliestArrivals, destinations) {
+        var _a, _b;
+        let earliestArrivalAtAnyDestination = UNREACHED;
+        for (const destination of destinations) {
+            const arrival = (_b = (_a = earliestArrivals.get(destination.id)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+            earliestArrivalAtAnyDestination = Time.min(earliestArrivalAtAnyDestination, arrival);
+        }
+        return earliestArrivalAtAnyDestination;
+    }
     /**
      * The main Raptor algorithm implementation.
      *
@@ -20257,12 +21321,12 @@ class Router {
      * @returns A result object containing data structures allowing to reconstruct routes and .
      */
     route(query) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e;
         const { from, to, departureTime, options } = query;
         // Consider children or siblings of the "from" stop as potential origins
         const origins = this.stopsIndex.equivalentStops(from);
         // Consider children or siblings of the "to" stop(s) as potential destinations
-        const destinations = to.flatMap((destination) => this.stopsIndex.equivalentStops(destination));
+        const destinations = Array.from(to).flatMap((destination) => this.stopsIndex.equivalentStops(destination));
         const earliestArrivals = new Map();
         const earliestArrivalsWithoutAnyLeg = new Map();
         const earliestArrivalsPerRound = [earliestArrivalsWithoutAnyLeg];
@@ -20271,12 +21335,12 @@ class Router {
         for (const originStop of origins) {
             markedStops.add(originStop.id);
             earliestArrivals.set(originStop.id, {
-                time: departureTime,
+                arrival: departureTime,
                 legNumber: 0,
                 origin: originStop.id,
             });
             earliestArrivalsWithoutAnyLeg.set(originStop.id, {
-                time: departureTime,
+                arrival: departureTime,
                 legNumber: 0,
                 origin: originStop.id,
             });
@@ -20292,38 +21356,19 @@ class Router {
             const reachableRoutes = this.timetable.findReachableRoutes(markedStops, options.transportModes);
             markedStops.clear();
             // for each route that can be reached with at least round - 1 trips
-            for (const [routeId, hopOnStop] of reachableRoutes.entries()) {
-                const route = this.timetable.getRoute(routeId);
+            for (const [route, hopOnStop] of reachableRoutes.entries()) {
                 let currentTrip = undefined;
-                const hopOnIndex = route.stopIndices.get(hopOnStop);
-                // for each stop in the route starting with the hop-on one
-                for (let i = hopOnIndex; i < route.stops.length; i++) {
-                    const currentStop = route.stops[i];
-                    const stopNumbers = route.stops.length;
+                for (const currentStop of route.stopsIterator(hopOnStop)) {
                     if (currentTrip !== undefined) {
-                        const currentArrivalIndex = (currentTrip.trip * stopNumbers + i) * 2;
-                        const currentArrivalTime = Time.fromMinutes(route.stopTimes[currentArrivalIndex]);
-                        const currentDropOffType = route.pickUpDropOffTypes[i * 2 + 1];
-                        const earliestArrivalAtCurrentStop = (_b = (_a = earliestArrivals.get(currentStop)) === null || _a === undefined ? undefined : _a.time) !== null && _b !== undefined ? _b : UNREACHED;
-                        let arrivalToImprove = earliestArrivalAtCurrentStop;
-                        if (destinations.length > 0) {
-                            const earliestArrivalsAtDestinations = [];
-                            // if multiple destinations are specified, the target pruning
-                            // should compare to the earliest arrival at any of them
-                            for (const destinationStop of destinations) {
-                                const earliestArrivalAtDestination = (_d = (_c = earliestArrivals.get(destinationStop.id)) === null || _c === undefined ? undefined : _c.time) !== null && _d !== undefined ? _d : UNREACHED;
-                                earliestArrivalsAtDestinations.push(earliestArrivalAtDestination);
-                            }
-                            const earliestArrivalAtDestination = Time.min(...earliestArrivalsAtDestinations);
-                            arrivalToImprove = Time.min(earliestArrivalAtCurrentStop, earliestArrivalAtDestination);
-                        }
-                        if (currentDropOffType !== NOT_AVAILABLE &&
-                            currentArrivalTime.toMinutes() < arrivalToImprove.toMinutes()) {
-                            const bestHopOnStopIndex = route.stopIndices.get(currentTrip.bestHopOnStop);
-                            const bestHopOnStopDepartureIndex = currentTrip.trip * stopNumbers * 2 + bestHopOnStopIndex * 2 + 1;
-                            const bestHopOnDepartureTime = Time.fromMinutes(route.stopTimes[bestHopOnStopDepartureIndex]);
+                        const currentArrivalTime = route.arrivalAt(currentStop, currentTrip.tripIndex);
+                        const currentDropOffType = route.dropOffTypeAt(currentStop, currentTrip.tripIndex);
+                        const earliestArrivalAtCurrentStop = (_b = (_a = earliestArrivals.get(currentStop)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+                        if (currentDropOffType !== 'NOT_AVAILABLE' &&
+                            currentArrivalTime.isBefore(earliestArrivalAtCurrentStop) &&
+                            currentArrivalTime.isBefore(this.earliestArrivalAtAnyStop(earliestArrivals, destinations))) {
+                            const bestHopOnDepartureTime = route.departureFrom(currentTrip.bestHopOnStop, currentTrip.tripIndex);
                             arrivalsAtCurrentRound.set(currentStop, {
-                                time: currentArrivalTime,
+                                arrival: currentArrivalTime,
                                 legNumber: round,
                                 origin: currentTrip.origin,
                                 leg: {
@@ -20331,11 +21376,11 @@ class Router {
                                     to: this.stopsIndex.findStopById(currentStop),
                                     departureTime: bestHopOnDepartureTime,
                                     arrivalTime: currentArrivalTime,
-                                    route: this.timetable.getServiceRoute(route.serviceRouteId),
+                                    route: this.timetable.getServiceRoute(route),
                                 },
                             });
                             earliestArrivals.set(currentStop, {
-                                time: currentArrivalTime,
+                                arrival: currentArrivalTime,
                                 legNumber: round,
                                 origin: currentTrip.origin,
                             });
@@ -20344,18 +21389,18 @@ class Router {
                     }
                     // check if we can catch a previous trip at the current stop
                     // if there was no current trip, find the first one reachable
-                    const earliestArrivalOnPreviousRound = (_e = arrivalsAtPreviousRound.get(currentStop)) === null || _e === undefined ? undefined : _e.time;
+                    const earliestArrivalOnPreviousRound = (_c = arrivalsAtPreviousRound.get(currentStop)) === null || _c === void 0 ? void 0 : _c.arrival;
                     if (earliestArrivalOnPreviousRound !== undefined &&
                         (currentTrip === undefined ||
-                            earliestArrivalOnPreviousRound.toMinutes() <=
-                                route.stopTimes[(currentTrip.trip * stopNumbers + i) * 2])) {
-                        const earliestTrip = this.timetable.findEarliestTrip(route, currentStop, currentTrip === null || currentTrip === undefined ? undefined : currentTrip.trip, earliestArrivalOnPreviousRound);
+                            earliestArrivalOnPreviousRound.isBefore(route.arrivalAt(currentStop, currentTrip.tripIndex)) ||
+                            earliestArrivalOnPreviousRound.equals(route.arrivalAt(currentStop, currentTrip.tripIndex)))) {
+                        const earliestTrip = route.findEarliestTrip(currentStop, earliestArrivalOnPreviousRound, currentTrip === null || currentTrip === void 0 ? void 0 : currentTrip.tripIndex);
                         if (earliestTrip !== undefined) {
                             currentTrip = {
-                                trip: earliestTrip,
+                                tripIndex: earliestTrip,
                                 // we need to keep track of the best hop-on stop to reconstruct the route at the end
                                 bestHopOnStop: currentStop,
-                                origin: (_g = (_f = arrivalsAtPreviousRound.get(currentStop)) === null || _f === undefined ? undefined : _f.origin) !== null && _g !== undefined ? _g : currentStop,
+                                origin: (_e = (_d = arrivalsAtPreviousRound.get(currentStop)) === null || _d === void 0 ? void 0 : _d.origin) !== null && _e !== void 0 ? _e : currentStop,
                             };
                         }
                     }
@@ -20369,31 +21414,97 @@ class Router {
     }
 }
 
-const prettyPrintRoute = (route) => {
-    route.legs.forEach((leg, index) => {
-        var _a;
-        const fromStop = `From: ${leg.from.name}${leg.from.platform ? ' (Pl. ' + leg.from.platform + ')' : ''}`;
-        const toStop = `To: ${leg.to.name}${leg.to.platform ? ' (Pl. ' + leg.to.platform + ')' : ''}`;
-        let transferDetails = '';
-        let travelDetails = '';
-        if ('minTransferTime' in leg) {
-            transferDetails = `Minimum Transfer Time: ${(_a = leg.minTransferTime) === null || _a === undefined ? undefined : _a.toString()}`;
-        }
-        if ('route' in leg && 'departureTime' in leg && 'arrivalTime' in leg) {
-            travelDetails = `Route: ${leg.route.type} ${leg.route.name}, Departure: ${leg.departureTime.toString()}, Arrival: ${leg.arrivalTime.toString()}`;
+/**
+ *
+ * @param filePath
+ * @returns
+ */
+const loadQueriesFromJson = (filePath) => {
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const serializedQueries = JSON.parse(fileContent);
+    return serializedQueries.map((serializedQuery) => {
+        const queryBuilder = new Query.Builder()
+            .from(serializedQuery.from)
+            .to(new Set(serializedQuery.to))
+            .departureTime(Time.fromString(serializedQuery.departureTime));
+        if (serializedQuery.maxTransfers !== undefined) {
+            queryBuilder.maxTransfers(serializedQuery.maxTransfers);
         }
-        console.log(`Leg ${index + 1}:`);
-        console.log(`  ${fromStop}`);
-        console.log(`  ${toStop}`);
-        if (transferDetails) {
-            console.log(`  ${transferDetails}`);
+        return queryBuilder.build();
+    });
+};
+/**
+ *
+ * @param router
+ * @param stopsIndex
+ * @param tasks
+ * @param iterations
+ * @returns
+ */
+const testRouterPerformance = (router, stopsIndex, tasks, iterations) => {
+    const results = [];
+    for (const task of tasks) {
+        const fromStop = stopsIndex.findStopBySourceStopId(task.from);
+        const toStops = Array.from(task.to).map((stopId) => stopsIndex.findStopBySourceStopId(stopId));
+        if (!fromStop || toStops.some((toStop) => !toStop)) {
+            throw new Error(`Invalid task: Start or end station not found for task ${JSON.stringify(task)}`);
         }
-        if (travelDetails) {
-            console.log(`  ${travelDetails}`);
+        let totalTime = 0;
+        let totalMemory = 0;
+        for (let i = 0; i < iterations; i++) {
+            if (global.gc) {
+                global.gc();
+            }
+            const startMemory = process.memoryUsage().heapUsed;
+            const startTime = performance.now();
+            router.route(task);
+            const endTime = performance.now();
+            const endMemory = process.memoryUsage().heapUsed;
+            totalTime += endTime - startTime;
+            if (endMemory >= startMemory) {
+                totalMemory += endMemory - startMemory;
+            }
         }
+        results.push({
+            task,
+            meanTimeMs: totalTime / iterations,
+            meanMemoryMb: totalMemory / iterations / (1024 * 1024),
+        });
+    }
+    return results;
+};
+/**
+ *
+ * @param results
+ * @returns
+ */
+const prettyPrintPerformanceResults = (results) => {
+    if (results.length === 0) {
+        console.log('No performance results to display.');
+        return;
+    }
+    const overallMeanTimeMs = results.reduce((sum, result) => sum + result.meanTimeMs, 0) /
+        results.length;
+    const overallMeanMemoryMb = results.reduce((sum, result) => sum + result.meanMemoryMb, 0) /
+        results.length;
+    console.log('Overall Performance Results:');
+    console.log(`  Mean Time (ms): ${overallMeanTimeMs.toFixed(2)}`);
+    console.log(`  Mean Memory (MB): ${overallMeanMemoryMb.toFixed(2)}`);
+    console.log('');
+    console.log('Individual Task Results:');
+    results.forEach((result, index) => {
+        console.log(`Task ${index + 1}:`);
+        console.log(`  Mean Time (ms): ${result.meanTimeMs.toFixed(2)}`);
+        console.log(`  Mean Memory (MB): ${result.meanMemoryMb.toFixed(2)}`);
         console.log('');
     });
 };
+
+/**
+ * Plots the graph of the result to a dot file.
+ * @param result - The result object to plot.
+ * @param filePath - The path where the dot file will be saved.
+ */
 const plotGraphToDotFile = (result, filePath) => {
     const plotter = new Plotter(result);
     const dotContent = plotter.plotDotGraph();
@@ -20414,9 +21525,22 @@ const startRepl = (stopsPath, timetablePath) => {
         help: 'Find stops by name using .find <query>',
         action(query) {
             this.clearBufferedCommand();
-            const stops = stopsIndex.findStopsByName(query);
+            let stops = [];
+            const stopBySourceId = stopsIndex.findStopBySourceStopId(query);
+            if (stopBySourceId !== undefined) {
+                stops.push(stopBySourceId);
+            }
+            else if (!isNaN(Number(query))) {
+                const stopById = stopsIndex.findStopById(Number(query));
+                if (stopById !== undefined) {
+                    stops.push(stopById);
+                }
+            }
+            else {
+                stops = stopsIndex.findStopsByName(query);
+            }
             stops.forEach((stop) => {
-                console.log(`${stop.name} (${stop.id})`);
+                console.log(`${stop.name} (${stop.sourceStopId} - ${stop.id})`);
             });
             this.displayPrompt();
         },
@@ -20439,17 +21563,21 @@ const startRepl = (stopsPath, timetablePath) => {
             const fromIndex = parts.indexOf('from');
             const toIndex = parts.indexOf('to');
             const fromId = parts.slice(fromIndex + 1, toIndex).join(' ');
-            const toId = parts
-                .slice(toIndex + 1, withTransfersIndex === -1 ? parts.indexOf('at') : parts.indexOf('at'))
-                .join(' ');
+            const toId = parts.slice(toIndex + 1, parts.indexOf('at')).join(' ');
             if (!fromId || !toId || !atTime) {
                 console.log('Usage: .route from <stationIdOrName> to <stationIdOrName> at <HH:mm> [with <N> transfers]');
                 this.displayPrompt();
                 return;
             }
             const fromStop = stopsIndex.findStopBySourceStopId(fromId) ||
+                (isNaN(Number(fromId))
+                    ? undefined
+                    : stopsIndex.findStopById(Number(fromId))) ||
                 stopsIndex.findStopsByName(fromId)[0];
             const toStop = stopsIndex.findStopBySourceStopId(toId) ||
+                (isNaN(Number(toId))
+                    ? undefined
+                    : stopsIndex.findStopById(Number(toId))) ||
                 stopsIndex.findStopsByName(toId)[0];
             if (!fromStop) {
                 console.log(`No stop found for 'from' ID or name: ${fromId}`);
@@ -20465,7 +21593,7 @@ const startRepl = (stopsPath, timetablePath) => {
             try {
                 const query = new Query.Builder()
                     .from(fromStop.sourceStopId)
-                    .to([toStop.sourceStopId])
+                    .to(toStop.sourceStopId)
                     .departureTime(departureTime)
                     .maxTransfers(maxTransfers)
                     .build();
@@ -20476,12 +21604,13 @@ const startRepl = (stopsPath, timetablePath) => {
                     console.log(`Destination not reachable`);
                 }
                 else {
-                    console.log(`Arriving to ${toStop.name} at ${arrivalTime.time.toString()} with ${arrivalTime.legNumber - 1} transfers from ${(_a = stopsIndex.findStopById(arrivalTime.origin)) === null || _a === void 0 ? void 0 : _a.name}.`);
+                    console.log(`Arriving to ${toStop.name} at ${arrivalTime.arrival.toString()} with ${arrivalTime.legNumber - 1} transfers from ${(_a = stopsIndex.findStopById(arrivalTime.origin)) === null || _a === void 0 ? void 0 : _a.name}.`);
                 }
                 const bestRoute = result.bestRoute(toStop.sourceStopId);
                 if (bestRoute) {
                     console.log(`Found route from ${fromStop.name} to ${toStop.name}:`);
-                    prettyPrintRoute(bestRoute);
+                    console.log(bestRoute.toString());
+                    console.log(JSON.stringify(bestRoute.asJson(), null, 2));
                 }
                 else {
                     console.log('No route found');
@@ -20543,7 +21672,7 @@ const startRepl = (stopsPath, timetablePath) => {
             try {
                 const query = new Query.Builder()
                     .from(fromStop.sourceStopId)
-                    .to([toStop.sourceStopId])
+                    .to(toStop.sourceStopId)
                     .departureTime(departureTime)
                     .maxTransfers(maxTransfers)
                     .build();
@@ -20576,7 +21705,7 @@ program
     .option('-s, --stopsOutputPath <path>', 'Path to output stops file', '/tmp/stops')
     .option('-p, --profileName <name>', 'Profile name for GTFS config', 'CH')
     .option('-v, --verbose', 'Verbose mode', false)
-    .action((gtfsPath, options) => __awaiter(undefined, undefined, undefined, function* () {
+    .action((gtfsPath, options) => __awaiter(void 0, void 0, void 0, function* () {
     if (options.verbose) {
         log.setDefaultLevel(log.levels.INFO);
     }
@@ -20590,12 +21719,12 @@ program
 }));
 program
     .command('parse-stops')
-    .description('Parse a GTFS feed and output a timetable and stops file.')
+    .description('Parse a GTFS feed and output a stops file.')
     .argument('<gtfsPath>', 'Path to GTFS data')
     .option('-s, --outputPath <path>', 'Path to output stops file', '/tmp/stops')
     .option('-p, --profileName <name>', 'Profile name for GTFS config', 'CH')
     .option('-v, --verbose', 'Verbose mode', false)
-    .action((gtfsPath, options) => __awaiter(undefined, undefined, undefined, function* () {
+    .action((gtfsPath, options) => __awaiter(void 0, void 0, void 0, function* () {
     if (options.verbose) {
         log.setDefaultLevel(log.levels.INFO);
     }
@@ -20614,5 +21743,20 @@ program
     .action((options) => {
     startRepl(options.stopsPath, options.timetablePath);
 });
+program
+    .command('perf')
+    .description('Evaluate the performance of the router on a set of routes.')
+    .argument('<routesPath>', 'Path to the JSON file containing the routes')
+    .option('-s, --stopsPath <path>', 'Path to the stops file', '/tmp/stops')
+    .option('-t, --timetablePath <path>', 'Path to the timetable file', '/tmp/timetable')
+    .option('-i, --iterations <number>', 'Number of iterations for performance tests', '20')
+    .action((routesPath, options) => {
+    const stopsIndex = StopsIndex.fromData(fs.readFileSync(options.stopsPath));
+    const timetable = Timetable.fromData(fs.readFileSync(options.timetablePath));
+    const router = new Router(timetable, stopsIndex);
+    const queries = loadQueriesFromJson(routesPath);
+    const performanceResults = testRouterPerformance(router, stopsIndex, queries, parseInt(options.iterations, 10));
+    prettyPrintPerformanceResults(performanceResults);
+});
 program.parse(process.argv);
 //# sourceMappingURL=cli.mjs.map