gtfs-to-html 2.7.2 → 2.8.1

package/dist/index.js

@@ -0,0 +1,2165 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/gtfs-to-html.ts
+import path2 from "node:path";
+import { mkdir as mkdir2, writeFile } from "node:fs/promises";
+import { map } from "lodash-es";
+import { openDb as openDb2, importGtfs } from "gtfs";
+import sanitize2 from "sanitize-filename";
+import Timer from "timer-machine";
+
+// src/lib/file-utils.ts
+import path from "node:path";
+import { createWriteStream } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { readFile, rm, mkdir } from "node:fs/promises";
+import copydir from "copy-dir";
+import _ from "lodash-es";
+import archiver from "archiver";
+import beautify from "js-beautify";
+import { renderFile } from "pug";
+import puppeteer from "puppeteer";
+import sanitize from "sanitize-filename";
+import untildify from "untildify";
+import insane from "insane";
+import { marked } from "marked";
+
+// src/lib/formatters.ts
+import {
+  clone,
+  find as find2,
+  first as first2,
+  groupBy as groupBy2,
+  last as last2,
+  omit,
+  sortBy as sortBy2,
+  zipObject
+} from "lodash-es";
+import moment3 from "moment";
+
+// src/lib/time-utils.ts
+import moment from "moment";
+function fromGTFSTime(timeString) {
+  const duration = moment.duration(timeString);
+  return moment({
+    hour: duration.hours(),
+    minute: duration.minutes(),
+    second: duration.seconds()
+  });
+}
+function toGTFSTime(time) {
+  return time.format("HH:mm:ss");
+}
+function fromGTFSDate(gtfsDate) {
+  return moment(gtfsDate, "YYYYMMDD");
+}
+function toGTFSDate(date) {
+  return moment(date).format("YYYYMMDD");
+}
+function calendarToCalendarCode(c) {
+  if (c.service_id) {
+    return c.service_id;
+  }
+  return `${c.monday}${c.tuesday}${c.wednesday}${c.thursday}${c.friday}${c.saturday}${c.sunday}`;
+}
+function calendarCodeToCalendar(code) {
+  const days2 = [
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday"
+  ];
+  const calendar = {};
+  for (const [index, day] of days2.entries()) {
+    calendar[day] = code[index];
+  }
+  return calendar;
+}
+function secondsAfterMidnight(timeString) {
+  return moment.duration(timeString).asSeconds();
+}
+function minutesAfterMidnight(timeString) {
+  return moment.duration(timeString).asMinutes();
+}
+function updateTimeByOffset(timeString, offsetSeconds) {
+  const newTime = fromGTFSTime(timeString);
+  return toGTFSTime(newTime.add(offsetSeconds, "seconds"));
+}
+
+// src/lib/utils.ts
+import {
+  cloneDeep,
+  compact,
+  countBy,
+  entries,
+  every as every2,
+  find,
+  findLast,
+  first,
+  flatMap as flatMap2,
+  flattenDeep,
+  flow,
+  isEqual,
+  groupBy,
+  head,
+  last,
+  maxBy,
+  partialRight,
+  reduce,
+  size,
+  some,
+  sortBy,
+  uniq,
+  uniqBy,
+  zip
+} from "lodash-es";
+import {
+  getCalendarDates,
+  getTrips,
+  getTimetableNotesReferences,
+  getTimetableNotes,
+  getRoutes,
+  getCalendars,
+  getTimetableStopOrders,
+  getStops,
+  getStopAttributes,
+  getStoptimes,
+  getFrequencies,
+  getTimetables,
+  getTimetablePages,
+  getAgencies,
+  openDb
+} from "gtfs";
+import { stringify } from "csv-stringify";
+import moment2 from "moment";
+import sqlString from "sqlstring";
+import toposort from "toposort";
+
+// src/lib/geojson-utils.ts
+import { getShapesAsGeoJSON, getStopsAsGeoJSON } from "gtfs";
+import { flatMap } from "lodash-es";
+import simplify from "@turf/simplify";
+import { featureCollection, round } from "@turf/helpers";
+var mergeGeojson = (...geojsons) => featureCollection(flatMap(geojsons, (geojson) => geojson.features));
+var truncateGeoJSONDecimals = (geojson, config) => {
+  for (const feature of geojson.features) {
+    if (feature.geometry.coordinates) {
+      if (feature.geometry.type.toLowerCase() === "point") {
+        feature.geometry.coordinates = feature.geometry.coordinates.map(
+          (number) => round(number, config.coordinatePrecision)
+        );
+      } else if (feature.geometry.type.toLowerCase() === "linestring") {
+        feature.geometry.coordinates = feature.geometry.coordinates.map(
+          (coordinate) => coordinate.map(
+            (number) => round(number, config.coordinatePrecision)
+          )
+        );
+      } else if (feature.geometry.type.toLowerCase() === "multilinestring") {
+        feature.geometry.coordinates = feature.geometry.coordinates.map(
+          (linestring) => linestring.map(
+            (coordinate) => coordinate.map(
+              (number) => round(number, config.coordinatePrecision)
+            )
+          )
+        );
+      }
+    }
+  }
+  return geojson;
+};
+var simplifyGeoJSON = (geojson, config) => {
+  try {
+    const simplifiedGeojson = simplify(geojson, {
+      tolerance: 1 / 10 ** config.coordinatePrecision,
+      highQuality: true
+    });
+    return truncateGeoJSONDecimals(simplifiedGeojson, config);
+  } catch {
+    config.logWarning("Unable to simplify geojson");
+    return truncateGeoJSONDecimals(geojson, config);
+  }
+};
+function getTimetableGeoJSON(timetable, config) {
+  const shapesGeojsons = timetable.route_ids.map(
+    (routeId) => getShapesAsGeoJSON({
+      route_id: routeId,
+      direction_id: timetable.direction_id,
+      trip_id: timetable.orderedTrips.map((trip) => trip.trip_id)
+    })
+  );
+  const stopsGeojsons = timetable.route_ids.map(
+    (routeId) => getStopsAsGeoJSON({
+      route_id: routeId,
+      direction_id: timetable.direction_id,
+      trip_id: timetable.orderedTrips.map((trip) => trip.trip_id)
+    })
+  );
+  const geojson = mergeGeojson(...shapesGeojsons, ...stopsGeojsons);
+  return simplifyGeoJSON(geojson, config);
+}
+function getAgencyGeoJSON(config) {
+  const shapesGeojsons = getShapesAsGeoJSON();
+  const stopsGeojsons = getStopsAsGeoJSON();
+  const geojson = mergeGeojson(shapesGeojsons, stopsGeojsons);
+  return simplifyGeoJSON(geojson, config);
+}
+
+// src/lib/template-functions.ts
+var template_functions_exports = {};
+__export(template_functions_exports, {
+  formatHtmlId: () => formatHtmlId,
+  formatTripName: () => formatTripName,
+  formatTripNameForCSV: () => formatTripNameForCSV,
+  getNotesForStop: () => getNotesForStop,
+  getNotesForStoptime: () => getNotesForStoptime,
+  getNotesForTimetableLabel: () => getNotesForTimetableLabel,
+  getNotesForTrip: () => getNotesForTrip,
+  hasNotesOrNotices: () => hasNotesOrNotices,
+  timetableHasDifferentDays: () => timetableHasDifferentDays,
+  timetablePageHasDifferentDays: () => timetablePageHasDifferentDays,
+  timetablePageHasDifferentLabels: () => timetablePageHasDifferentLabels
+});
+import { every } from "lodash-es";
+function formatHtmlId(id) {
+  return id.replace(/([^\w[\]{}.:-])\s?/g, "");
+}
+function timetableHasDifferentDays(timetable) {
+  return !every(timetable.orderedTrips, (trip, idx) => {
+    if (idx === 0) {
+      return true;
+    }
+    return trip.dayList === timetable.orderedTrips[idx - 1].dayList;
+  });
+}
+function timetablePageHasDifferentDays(timetablePage) {
+  return !every(timetablePage.consolidatedTimetables, (timetable, idx) => {
+    if (idx === 0) {
+      return true;
+    }
+    return timetable.dayListLong === timetablePage.consolidatedTimetables[idx - 1].dayListLong;
+  });
+}
+function timetablePageHasDifferentLabels(timetablePage) {
+  return !every(timetablePage.consolidatedTimetables, (timetable, idx) => {
+    if (idx === 0) {
+      return true;
+    }
+    return timetable.timetable_label === timetablePage.consolidatedTimetables[idx - 1].timetable_label;
+  });
+}
+function hasNotesOrNotices(timetable) {
+  return timetable.requestPickupSymbolUsed || timetable.noPickupSymbolUsed || timetable.requestDropoffSymbolUsed || timetable.noDropoffSymbolUsed || timetable.noServiceSymbolUsed || timetable.interpolatedStopSymbolUsed || timetable.notes.length > 0;
+}
+function getNotesForTimetableLabel(notes) {
+  return notes.filter((note) => !note.stop_id && !note.trip_id);
+}
+function getNotesForStop(notes, stop) {
+  return notes.filter((note) => {
+    if (note.trip_id) {
+      return false;
+    }
+    if (note.stop_sequence && !stop.trips.some((trip) => trip.stop_sequence === note.stop_sequence)) {
+      return false;
+    }
+    return note.stop_id === stop.stop_id;
+  });
+}
+function getNotesForTrip(notes, trip) {
+  return notes.filter((note) => {
+    if (note.stop_id) {
+      return false;
+    }
+    return note.trip_id === trip.trip_id;
+  });
+}
+function getNotesForStoptime(notes, stoptime) {
+  return notes.filter((note) => {
+    if (!note.trip_id && note.stop_id === stoptime.stop_id && note.show_on_stoptime === 1) {
+      return true;
+    }
+    if (!note.stop_id && note.trip_id === stoptime.trip_id && note.show_on_stoptime === 1) {
+      return true;
+    }
+    return note.trip_id === stoptime.trip_id && note.stop_id === stoptime.stop_id;
+  });
+}
+function formatTripName(trip, index, timetable) {
+  let tripName;
+  if (timetable.routes.length > 1) {
+    tripName = trip.route_short_name;
+  } else if (timetable.orientation === "horizontal") {
+    if (trip.trip_short_name) {
+      tripName = trip.trip_short_name;
+    } else {
+      tripName = `Run #${index + 1}`;
+    }
+  }
+  if (timetableHasDifferentDays(timetable)) {
+    tripName += ` ${trip.dayList}`;
+  }
+  return tripName;
+}
+function formatTripNameForCSV(trip, timetable) {
+  let tripName = "";
+  if (timetable.routes.length > 1) {
+    tripName += `${trip.route_short_name} - `;
+  }
+  if (trip.trip_short_name) {
+    tripName += trip.trip_short_name;
+  } else {
+    tripName += trip.trip_id;
+  }
+  if (trip.trip_headsign) {
+    tripName += ` - ${trip.trip_headsign}`;
+  }
+  if (timetableHasDifferentDays(timetable)) {
+    tripName += ` - ${trip.dayList}`;
+  }
+  return tripName;
+}
+
+// package.json
+var version = "2.8.0";
+
+// src/lib/utils.ts
+var isTimepoint = (stoptime) => {
+  if (isNullOrEmpty(stoptime.timepoint)) {
+    return !isNullOrEmpty(stoptime.arrival_time) && !isNullOrEmpty(stoptime.departure_time);
+  }
+  return stoptime.timepoint === 1;
+};
+var getLongestTripStoptimes = (trips, config) => {
+  const filteredTripStoptimes = trips.map(
+    (trip) => trip.stoptimes.filter((stoptime) => {
+      if (config.showOnlyTimepoint === true) {
+        return isTimepoint(stoptime);
+      }
+      return true;
+    })
+  );
+  return maxBy(filteredTripStoptimes, (stoptimes) => size(stoptimes));
+};
+var findCommonStopId = (trips, config) => {
+  const longestTripStoptimes = getLongestTripStoptimes(trips, config);
+  if (!longestTripStoptimes) {
+    return null;
+  }
+  const commonStoptime = longestTripStoptimes.find((stoptime, idx) => {
+    if (idx === 0 && stoptime.stop_id === last(longestTripStoptimes).stop_id) {
+      return false;
+    }
+    if (isNullOrEmpty(stoptime.arrival_time)) {
+      return false;
+    }
+    return every2(
+      trips,
+      (trip) => trip.stoptimes.find(
+        (tripStoptime) => tripStoptime.stop_id === stoptime.stop_id && tripStoptime.arrival_time !== null
+      )
+    );
+  });
+  return commonStoptime ? commonStoptime.stop_id : null;
+};
+var deduplicateTrips = (trips, commonStopId) => {
+  const deduplicatedTrips = [];
+  for (const trip of trips) {
+    if (deduplicatedTrips.length === 0 || trip.stoptimes.length === 0) {
+      deduplicatedTrips.push(trip);
+      continue;
+    }
+    const stoptimes = trip.stoptimes.map((stoptime) => stoptime.departure_time);
+    const selectedStoptime = commonStopId ? find(trip.stoptimes, {
+      stop_id: commonStopId
+    }) : trip.stoptimes[0];
+    const similarTrips = deduplicatedTrips.filter((trip2) => {
+      const stoptime = find(trip2.stoptimes, {
+        stop_id: selectedStoptime.stop_id
+      });
+      if (!stoptime) {
+        return false;
+      }
+      return stoptime.departure_time === selectedStoptime.departure_time;
+    });
+    const tripIsUnique = every2(similarTrips, (similarTrip) => {
+      const similarTripStoptimes = similarTrip.stoptimes.map(
+        (stoptime) => stoptime.departure_time
+      );
+      return !isEqual(stoptimes, similarTripStoptimes);
+    });
+    if (tripIsUnique) {
+      deduplicatedTrips.push(trip);
+    }
+  }
+  return deduplicatedTrips;
+};
+var sortTrips = (trips, config) => {
+  let sortedTrips;
+  let commonStopId;
+  if (config.sortingAlgorithm === "common") {
+    commonStopId = findCommonStopId(trips, config);
+    if (commonStopId) {
+      sortedTrips = sortTripsByStoptimeAtStop(trips, commonStopId);
+    } else {
+      sortedTrips = sortTrips(trips, {
+        ...config,
+        sortingAlgorithm: "beginning"
+      });
+    }
+  } else if (config.sortingAlgorithm === "beginning") {
+    for (const trip of trips) {
+      if (trip.stoptimes.length === 0) {
+        continue;
+      }
+      trip.firstStoptime = timeToSeconds(first(trip.stoptimes).departure_time);
+      trip.lastStoptime = timeToSeconds(last(trip.stoptimes).departure_time);
+    }
+    sortedTrips = sortBy(
+      trips,
+      ["firstStoptime", "lastStoptime"],
+      ["asc", "asc"]
+    );
+  } else if (config.sortingAlgorithm === "end") {
+    for (const trip of trips) {
+      if (trip.stoptimes.length === 0) {
+        continue;
+      }
+      trip.firstStoptime = timeToSeconds(first(trip.stoptimes).departure_time);
+      trip.lastStoptime = timeToSeconds(last(trip.stoptimes).departure_time);
+    }
+    sortedTrips = sortBy(
+      trips,
+      ["lastStoptime", "firstStoptime"],
+      ["asc", "asc"]
+    );
+  } else if (config.sortingAlgorithm === "first") {
+    const longestTripStoptimes = getLongestTripStoptimes(trips, config);
+    const firstStopId = first(longestTripStoptimes).stop_id;
+    sortedTrips = sortTripsByStoptimeAtStop(trips, firstStopId);
+  } else if (config.sortingAlgorithm === "last") {
+    const longestTripStoptimes = getLongestTripStoptimes(trips, config);
+    const lastStopId = last(longestTripStoptimes).stop_id;
+    sortedTrips = sortTripsByStoptimeAtStop(trips, lastStopId);
+  }
+  return deduplicateTrips(sortedTrips, commonStopId);
+};
+var sortTripsByStoptimeAtStop = (trips, stopId) => sortBy(trips, (trip) => {
+  const stoptime = find(trip.stoptimes, { stop_id: stopId });
+  return stoptime ? timeToSeconds(stoptime.departure_time) : void 0;
+});
+var getCalendarDatesForTimetable = (timetable, config) => {
+  const calendarDates = getCalendarDates(
+    {
+      service_id: timetable.service_ids
+    },
+    [],
+    [["date", "ASC"]]
+  );
+  const start = fromGTFSDate(timetable.start_date);
+  const end = fromGTFSDate(timetable.end_date);
+  const excludedDates = [];
+  const includedDates = [];
+  for (const calendarDate of calendarDates) {
+    if (moment2(calendarDate.date, "YYYYMMDD").isBetween(start, end)) {
+      if (calendarDate.exception_type === 1) {
+        includedDates.push(formatDate(calendarDate, config.dateFormat));
+      } else if (calendarDate.exception_type === 2) {
+        excludedDates.push(formatDate(calendarDate, config.dateFormat));
+      }
+    }
+  }
+  const includedAndExcludedDates = excludedDates.filter(
+    (date) => includedDates.includes(date)
+  );
+  return {
+    excludedDates: excludedDates.filter(
+      (date) => !includedAndExcludedDates.includes(date)
+    ),
+    includedDates: includedDates.filter(
+      (date) => !includedAndExcludedDates.includes(date)
+    )
+  };
+};
+var getDaysFromCalendars = (calendars) => {
+  const days2 = {
+    monday: 0,
+    tuesday: 0,
+    wednesday: 0,
+    thursday: 0,
+    friday: 0,
+    saturday: 0,
+    sunday: 0
+  };
+  for (const calendar of calendars) {
+    for (const [day, value] of Object.entries(days2)) {
+      days2[day] = value | calendar[day];
+    }
+  }
+  return days2;
+};
+var getDirectionHeadsignFromTimetable = (timetable) => {
+  const trips = getTrips(
+    {
+      direction_id: timetable.direction_id,
+      route_id: timetable.route_ids
+    },
+    ["trip_headsign"]
+  );
+  if (trips.length === 0) {
+    return "";
+  }
+  const mostCommonHeadsign = flow(
+    countBy,
+    entries,
+    partialRight(maxBy, last),
+    head
+  )(compact(trips.map((trip) => trip.trip_headsign)));
+  return mostCommonHeadsign;
+};
+var getTimetableNotesForTimetable = (timetable, config) => {
+  const noteReferences = [
+    // Get all notes for this timetable.
+    ...getTimetableNotesReferences({
+      timetable_id: timetable.timetable_id
+    }),
+    // Get all notes for this route.
+    ...getTimetableNotesReferences({
+      route_id: timetable.routes.map((route) => route.route_id),
+      timetable_id: null
+    }),
+    // Get all notes for all trips in this timetable.
+    ...getTimetableNotesReferences({
+      trip_id: timetable.orderedTrips.map((trip) => trip.trip_id)
+    }),
+    // Get all notes for all stops in this timetable.
+    ...getTimetableNotesReferences({
+      stop_id: timetable.stops.map((stop) => stop.stop_id),
+      trip_id: null,
+      route_id: null,
+      timetable_id: null
+    })
+  ];
+  const usedNoteReferences = [];
+  for (const noteReference of noteReferences) {
+    if (noteReference.stop_sequence === "" || noteReference.stop_sequence === null) {
+      usedNoteReferences.push(noteReference);
+      continue;
+    }
+    if (noteReference.stop_id === "" || noteReference.stop_id === null) {
+      config.logWarning(
+        `Timetable Note Reference for note_id=${noteReference.note_id} has a \`stop_sequence\` but no \`stop_id\` - ignoring`
+      );
+      continue;
+    }
+    const stop = timetable.stops.find(
+      (stop2) => stop2.stop_id === noteReference.stop_id
+    );
+    if (!stop) {
+      continue;
+    }
+    const tripWithMatchingStopSequence = stop.trips.find(
+      (trip) => trip.stop_sequence === noteReference.stop_sequence
+    );
+    if (tripWithMatchingStopSequence) {
+      usedNoteReferences.push(noteReference);
+    }
+  }
+  const notes = getTimetableNotes({
+    note_id: usedNoteReferences.map((noteReference) => noteReference.note_id)
+  });
+  const symbols = "abcdefghijklmnopqrstuvwxyz".split("");
+  let symbolIndex = 0;
+  for (const note of notes) {
+    if (note.symbol === "" || note.symbol === null) {
+      note.symbol = symbolIndex < symbols.length - 1 ? symbols[symbolIndex] : symbolIndex - symbols.length;
+      symbolIndex += 1;
+    }
+  }
+  const formattedNotes = usedNoteReferences.map((noteReference) => ({
+    ...noteReference,
+    ...notes.find((note) => note.note_id === noteReference.note_id)
+  }));
+  return sortBy(formattedNotes, "symbol");
+};
+var convertTimetableToTimetablePage = (timetable, config) => {
+  if (!timetable.routes) {
+    timetable.routes = getRoutes({
+      route_id: timetable.route_ids
+    });
+  }
+  const filename = generateFileName(timetable, config, "html");
+  return {
+    timetable_page_id: timetable.timetable_id,
+    timetable_page_label: timetable.timetable_label,
+    timetables: [timetable],
+    filename
+  };
+};
+var convertRouteToTimetablePage = (route, direction, calendars, calendarDates, config) => {
+  const timetable = {
+    route_ids: [route.route_id],
+    direction_id: direction ? direction.direction_id : void 0,
+    direction_name: direction ? direction.trip_headsign : void 0,
+    routes: [route],
+    include_exceptions: calendarDates && calendarDates.length > 0 ? 1 : 0,
+    service_id: calendarDates && calendarDates.length > 0 ? calendarDates[0].service_id : null,
+    service_notes: null,
+    timetable_label: null,
+    start_time: null,
+    end_time: null,
+    orientation: null,
+    timetable_sequence: null,
+    show_trip_continuation: null,
+    start_date: null,
+    end_date: null
+  };
+  if (calendars && calendars.length > 0) {
+    Object.assign(timetable, getDaysFromCalendars(calendars));
+    timetable.start_date = toGTFSDate(
+      moment2.min(
+        calendars.map((calendar) => fromGTFSDate(calendar.start_date))
+      )
+    );
+    timetable.end_date = toGTFSDate(
+      moment2.max(calendars.map((calendar) => fromGTFSDate(calendar.end_date)))
+    );
+  }
+  timetable.timetable_id = formatTimetableId(timetable);
+  return convertTimetableToTimetablePage(timetable, config);
+};
+var convertRoutesToTimetablePages = (config) => {
+  const db = openDb(config);
+  const routes = getRoutes();
+  let whereClause = "";
+  const whereClauses = [];
+  if (config.endDate) {
+    whereClauses.push(
+      `start_date <= ${sqlString.escape(toGTFSDate(moment2(config.endDate)))}`
+    );
+  }
+  if (config.startDate) {
+    whereClauses.push(
+      `end_date >= ${sqlString.escape(toGTFSDate(moment2(config.startDate)))}`
+    );
+  }
+  if (whereClauses.length > 0) {
+    whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+  }
+  const calendars = db.prepare(`SELECT * FROM calendar ${whereClause}`).all();
+  const serviceIds = calendars.map((calendar) => calendar.service_id);
+  const calendarDates = db.prepare(
+    `SELECT * FROM calendar_dates WHERE exception_type = 1 AND service_id NOT IN (${serviceIds.map((serviceId) => `'${serviceId}'`).join(", ")})`
+  ).all();
+  const timetablePages = routes.map((route) => {
+    const trips = getTrips(
+      {
+        route_id: route.route_id
+      },
+      ["trip_headsign", "direction_id", "trip_id", "service_id"]
+    );
+    const directions = uniqBy(trips, (trip) => trip.direction_id);
+    const dayGroups = groupBy(calendars, calendarToCalendarCode);
+    const calendarDateGroups = groupBy(calendarDates, "service_id");
+    return directions.map((direction) => [
+      Object.values(dayGroups).map((calendars2) => {
+        const tripsForCalendars = trips.filter(
+          (trip) => some(calendars2, { service_id: trip.service_id })
+        );
+        if (tripsForCalendars.length > 0) {
+          return convertRouteToTimetablePage(
+            route,
+            direction,
+            calendars2,
+            null,
+            config
+          );
+        }
+      }),
+      Object.values(calendarDateGroups).map((calendarDates2) => {
+        const tripsForCalendarDates = trips.filter(
+          (trip) => some(calendarDates2, { service_id: trip.service_id })
+        );
+        if (tripsForCalendarDates.length > 0) {
+          return convertRouteToTimetablePage(
+            route,
+            direction,
+            null,
+            calendarDates2,
+            config
+          );
+        }
+      })
+    ]);
+  });
+  return compact(flattenDeep(timetablePages));
+};
+var generateTripsByFrequencies = (trip, frequencies, config) => {
+  const formattedFrequencies = frequencies.map(
+    (frequency) => formatFrequency(frequency, config)
+  );
+  const resetTrip = resetStoptimesToMidnight(trip);
+  const trips = [];
+  for (const frequency of formattedFrequencies) {
+    const startSeconds = secondsAfterMidnight(frequency.start_time);
+    const endSeconds = secondsAfterMidnight(frequency.end_time);
+    for (let offset = startSeconds; offset < endSeconds; offset += frequency.headway_secs) {
+      const newTrip = cloneDeep(resetTrip);
+      trips.push({
+        ...newTrip,
+        trip_id: `${resetTrip.trip_id}_freq_${trips.length}`,
+        stoptimes: updateStoptimesByOffset(newTrip, offset)
+      });
+    }
+  }
+  return trips;
+};
+var duplicateStopsForDifferentArrivalDeparture = (stopIds, timetable, config) => {
+  if (config.showArrivalOnDifference === null) {
+    return stopIds;
+  }
+  for (const trip of timetable.orderedTrips) {
+    for (const stoptime of trip.stoptimes) {
+      const timepointDifference = fromGTFSTime(stoptime.departure_time).diff(
+        fromGTFSTime(stoptime.arrival_time),
+        "minutes"
+      );
+      if (timepointDifference < config.showArrivalOnDifference) {
+        continue;
+      }
+      const index = stopIds.indexOf(stoptime.stop_id);
+      if (index === 0 || index === stopIds.length - 1) {
+        continue;
+      }
+      if (stoptime.stop_id === stopIds[index + 1] || stoptime.stop_id === stopIds[index - 1]) {
+        continue;
+      }
+      stopIds.splice(index, 0, stoptime.stop_id);
+    }
+  }
+  return stopIds;
+};
+var getStopOrder = (timetable, config) => {
+  const timetableStopOrders = getTimetableStopOrders(
+    {
+      timetable_id: timetable.timetable_id
+    },
+    ["stop_id"],
+    [["stop_sequence", "ASC"]]
+  );
+  if (timetableStopOrders.length > 0) {
+    return timetableStopOrders.map(
+      (timetableStopOrder) => timetableStopOrder.stop_id
+    );
+  }
+  try {
+    const stopGraph = [];
+    for (const trip of timetable.orderedTrips) {
+      const sortedStopIds = trip.stoptimes.filter((stoptime) => {
+        if (config.showOnlyTimepoint === true) {
+          return isTimepoint(stoptime);
+        }
+        return true;
+      }).map((stoptime) => stoptime.stop_id);
+      for (const [index, stopId] of sortedStopIds.entries()) {
+        if (index === sortedStopIds.length - 1) {
+          continue;
+        }
+        stopGraph.push([stopId, sortedStopIds[index + 1]]);
+      }
+    }
+    const stopIds2 = toposort(stopGraph);
+    return duplicateStopsForDifferentArrivalDeparture(
+      stopIds2,
+      timetable,
+      config
+    );
+  } catch {
+  }
+  const longestTripStoptimes = getLongestTripStoptimes(
+    timetable.orderedTrips,
+    config
+  );
+  const stopIds = longestTripStoptimes.map((stoptime) => stoptime.stop_id);
+  return duplicateStopsForDifferentArrivalDeparture(stopIds, timetable, config);
+};
+var getStopsForTimetable = (timetable, config) => {
+  if (timetable.orderedTrips.length === 0) {
+    return [];
+  }
+  const orderedStopIds = getStopOrder(timetable, config);
+  const orderedStops = orderedStopIds.map((stopId, index) => {
+    const stops = getStops({
+      stop_id: stopId
+    });
+    if (stops.length === 0) {
+      throw new Error(
+        `No stop found found for stop_id=${stopId} in timetable_id=${timetable.timetable_id}`
+      );
+    }
+    const stop = {
+      ...stops[0],
+      trips: []
+    };
+    if (index < orderedStopIds.length - 1 && stopId === orderedStopIds[index + 1]) {
+      stop.type = "arrival";
+    } else if (index > 0 && stopId === orderedStopIds[index - 1]) {
+      stop.type = "departure";
+    }
+    return stop;
+  });
+  if (timetable.showStopCity) {
+    const stopAttributes = getStopAttributes({
+      stop_id: orderedStopIds
+    });
+    for (const stopAttribute of stopAttributes) {
+      const stop = orderedStops.find(
+        (stop2) => stop2.stop_id === stopAttribute.stop_id
+      );
+      if (stop) {
+        stop.stop_city = stopAttribute.stop_city;
+      }
+    }
+  }
+  return orderedStops;
+};
+var getCalendarsFromTimetable = (timetable) => {
+  const db = openDb();
+  let whereClause = "";
+  const whereClauses = [];
+  if (timetable.end_date) {
+    if (!moment2(timetable.end_date, "YYYYMMDD", true).isValid()) {
+      throw new Error(
+        `Invalid end_date=${timetable.end_date} for timetable_id=${timetable.timetable_id}`
+      );
+    }
+    whereClauses.push(`start_date <= ${sqlString.escape(timetable.end_date)}`);
+  }
+  if (timetable.start_date) {
+    if (!moment2(timetable.start_date, "YYYYMMDD", true).isValid()) {
+      throw new Error(
+        `Invalid start_date=${timetable.start_date} for timetable_id=${timetable.timetable_id}`
+      );
+    }
+    whereClauses.push(`end_date >= ${sqlString.escape(timetable.start_date)}`);
+  }
+  const days2 = getDaysFromCalendars([timetable]);
+  const dayQueries = reduce(
+    days2,
+    (memo, value, key) => {
+      if (value === 1) {
+        memo.push(`${key} = 1`);
+      }
+      return memo;
+    },
+    []
+  );
+  if (dayQueries.length > 0) {
+    whereClauses.push(`(${dayQueries.join(" OR ")})`);
+  }
+  if (whereClauses.length > 0) {
+    whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+  }
+  return db.prepare(`SELECT * FROM calendar ${whereClause}`).all();
+};
+var getCalendarDatesServiceIds = (startDate, endDate) => {
+  const db = openDb();
+  const whereClauses = ["exception_type = 1"];
+  if (endDate) {
+    whereClauses.push(`date <= ${sqlString.escape(endDate)}`);
+  }
+  if (startDate) {
+    whereClauses.push(`date >= ${sqlString.escape(startDate)}`);
+  }
+  const calendarDates = db.prepare(
+    `SELECT DISTINCT service_id FROM calendar_dates WHERE ${whereClauses.join(
+      " AND "
+    )}`
+  ).all();
+  return calendarDates.map((calendarDate) => calendarDate.service_id);
+};
+var getAllStationStopIds = (stopId) => {
+  const stops = getStops({
+    stop_id: stopId
+  });
+  if (stops.length === 0) {
+    throw new Error(`No stop found for stop_id=${stopId}`);
+  }
+  const stop = stops[0];
+  if (isNullOrEmpty(stop.parent_station)) {
+    return [stopId];
+  }
+  const stopsInParentStation = getStops(
+    {
+      parent_station: stop.parent_station
+    },
+    ["stop_id"]
+  );
+  return [
+    stop.parent_station,
+    ...stopsInParentStation.map((stop2) => stop2.stop_id)
+  ];
+};
+var getTripsWithSameBlock = (trip, timetable) => {
+  const trips = getTrips(
+    {
+      block_id: trip.block_id,
+      service_id: timetable.service_ids
+    },
+    ["trip_id", "route_id"]
+  );
+  for (const blockTrip of trips) {
+    const stopTimes = getStoptimes(
+      {
+        trip_id: blockTrip.trip_id
+      },
+      [],
+      [["stop_sequence", "ASC"]]
+    );
+    if (stopTimes.length === 0) {
+      throw new Error(
+        `No stoptimes found found for trip_id=${blockTrip.trip_id}`
+      );
+    }
+    blockTrip.firstStoptime = first(stopTimes);
+    blockTrip.lastStoptime = last(stopTimes);
+  }
+  return sortBy(trips, (trip2) => trip2.firstStoptime.departure_timestamp);
+};
+var addTripContinuation = (trip, timetable) => {
+  if (!trip.block_id || trip.stoptimes.length === 0) {
+    return;
+  }
+  const maxContinuesAsWaitingTimeSeconds = 60 * 60;
+  const firstStoptime = first(trip.stoptimes);
+  const firstStopIds = getAllStationStopIds(firstStoptime.stop_id);
+  const lastStoptime = last(trip.stoptimes);
+  const lastStopIds = getAllStationStopIds(lastStoptime.stop_id);
+  const blockTrips = getTripsWithSameBlock(trip, timetable);
+  const previousTrip = findLast(
+    blockTrips,
+    (blockTrip) => blockTrip.lastStoptime.arrival_timestamp <= firstStoptime.departure_timestamp
+  );
+  if (previousTrip && previousTrip.route_id !== trip.route_id && previousTrip.lastStoptime.arrival_timestamp >= firstStoptime.departure_timestamp - maxContinuesAsWaitingTimeSeconds && firstStopIds.includes(previousTrip.lastStoptime.stop_id)) {
+    const routes = getRoutes({
+      route_id: previousTrip.route_id
+    });
+    previousTrip.route = routes[0];
+    trip.continues_from_route = previousTrip;
+  }
+  const nextTrip = find(
+    blockTrips,
+    (blockTrip) => blockTrip.firstStoptime.departure_timestamp >= lastStoptime.arrival_timestamp
+  );
+  if (nextTrip && nextTrip.route_id !== trip.route_id && nextTrip.firstStoptime.departure_timestamp <= lastStoptime.arrival_timestamp + maxContinuesAsWaitingTimeSeconds && lastStopIds.includes(nextTrip.firstStoptime.stop_id)) {
+    const routes = getRoutes({
+      route_id: nextTrip.route_id
+    });
+    nextTrip.route = routes[0];
+    trip.continues_as_route = nextTrip;
+  }
+};
+var filterTrips = (timetable) => {
+  let filteredTrips = timetable.orderedTrips;
+  for (const trip of filteredTrips) {
+    const combinedStoptimes = [];
+    for (const [index, stoptime] of trip.stoptimes.entries()) {
+      if (index === 0 || stoptime.stop_id !== trip.stoptimes[index - 1].stop_id) {
+        combinedStoptimes.push(stoptime);
+      } else {
+        combinedStoptimes[combinedStoptimes.length - 1].departure_time = stoptime.departure_time;
+      }
+    }
+    trip.stoptimes = combinedStoptimes;
+  }
+  const timetableStopIds = new Set(timetable.stops.map((stop) => stop.stop_id));
+  for (const trip of filteredTrips) {
+    trip.stoptimes = trip.stoptimes.filter(
+      (stoptime) => timetableStopIds.has(stoptime.stop_id)
+    );
+  }
+  filteredTrips = filteredTrips.filter((trip) => trip.stoptimes.length > 1);
+  return filteredTrips;
+};
+var getTripsForTimetable = (timetable, calendars, config) => {
+  const tripQuery = {
+    route_id: timetable.route_ids,
+    service_id: timetable.service_ids
+  };
+  if (!isNullOrEmpty(timetable.direction_id)) {
+    tripQuery.direction_id = timetable.direction_id;
+  }
+  const trips = getTrips(tripQuery);
+  if (trips.length === 0) {
+    timetable.warnings.push(
+      `No trips found for route_id=${timetable.route_ids.join(
+        "_"
+      )}, direction_id=${timetable.direction_id}, service_ids=${JSON.stringify(
+        timetable.service_ids
+      )}, timetable_id=${timetable.timetable_id}`
+    );
+  }
+  const frequencies = getFrequencies({
+    trip_id: trips.map((trip) => trip.trip_id)
+  });
+  timetable.service_ids = uniq(trips.map((trip) => trip.service_id));
+  const formattedTrips = [];
+  for (const trip of trips) {
+    const formattedTrip = formatTrip(trip, timetable, calendars, config);
+    formattedTrip.stoptimes = getStoptimes(
+      {
+        trip_id: formattedTrip.trip_id
+      },
+      [],
+      [["stop_sequence", "ASC"]]
+    );
+    if (formattedTrip.stoptimes.length === 0) {
+      timetable.warnings.push(
+        `No stoptimes found for trip_id=${formattedTrip.trip_id}, route_id=${timetable.route_ids.join("_")}, timetable_id=${timetable.timetable_id}`
+      );
+    }
+    if (timetable.start_timestamp !== "" && timetable.start_timestamp !== null && timetable.start_timestamp !== void 0 && trip.stoptimes[0].arrival_timestamp < timetable.start_timestamp) {
+      return;
+    }
+    if (timetable.end_timestamp !== "" && timetable.end_timestamp !== null && timetable.end_timestamp !== void 0 && trip.stoptimes[0].arrival_timestamp >= timetable.end_timestamp) {
+      return;
+    }
+    if (timetable.show_trip_continuation) {
+      addTripContinuation(formattedTrip, timetable);
+      if (formattedTrip.continues_as_route) {
+        timetable.has_continues_as_route = true;
+      }
+      if (formattedTrip.continues_from_route) {
+        timetable.has_continues_from_route = true;
+      }
+    }
+    const tripFrequencies = frequencies.filter(
+      (frequency) => frequency.trip_id === trip.trip_id
+    );
+    if (tripFrequencies.length === 0) {
+      formattedTrips.push(formattedTrip);
+    } else {
+      const frequencyTrips = generateTripsByFrequencies(
+        formattedTrip,
+        frequencies,
+        config
+      );
+      formattedTrips.push(...frequencyTrips);
+      timetable.frequencies = frequencies;
+      timetable.frequencyExactTimes = some(frequencies, {
+        exact_times: 1
+      });
+    }
+  }
+  if (config.useParentStation) {
+    const stopIds = [];
+    for (const trip of formattedTrips) {
+      for (const stoptime of trip.stoptimes) {
+        stopIds.push(stoptime.stop_id);
+      }
+    }
+    const stops = getStops(
+      {
+        stop_id: uniq(stopIds)
+      },
+      ["parent_station", "stop_id"]
+    );
+    for (const trip of formattedTrips) {
+      for (const stoptime of trip.stoptimes) {
+        const stop = stops.find((stop2) => stop2.stop_id === stoptime.stop_id);
+        if (stop?.parent_station) {
+          stoptime.stop_id = stop.parent_station;
+        }
+      }
+    }
+  }
+  return sortTrips(formattedTrips, config);
+};
+var formatTimetables = (timetables, config) => {
+  const formattedTimetables = timetables.map((timetable) => {
+    timetable.warnings = [];
+    const dayList = formatDays(timetable, config);
+    const calendars = getCalendarsFromTimetable(timetable);
+    let serviceIds = calendars.map((calendar) => calendar.service_id);
+    if (timetable.include_exceptions === 1) {
+      const calendarDatesServiceIds = getCalendarDatesServiceIds(
+        timetable.start_date,
+        timetable.end_date
+      );
+      serviceIds = uniq([...serviceIds, ...calendarDatesServiceIds]);
+    }
+    Object.assign(timetable, {
+      noServiceSymbolUsed: false,
+      requestDropoffSymbolUsed: false,
+      noDropoffSymbolUsed: false,
+      requestPickupSymbolUsed: false,
+      noPickupSymbolUsed: false,
+      interpolatedStopSymbolUsed: false,
+      showStopCity: config.showStopCity,
+      showStopDescription: config.showStopDescription,
+      noServiceSymbol: config.noServiceSymbol,
+      requestDropoffSymbol: config.requestDropoffSymbol,
+      noDropoffSymbol: config.noDropoffSymbol,
+      requestPickupSymbol: config.requestPickupSymbol,
+      noPickupSymbol: config.noPickupSymbol,
+      interpolatedStopSymbol: config.interpolatedStopSymbol,
+      orientation: timetable.orientation || config.defaultOrientation,
+      service_ids: serviceIds,
+      dayList,
+      dayListLong: formatDaysLong(dayList, config)
+    });
+    timetable.orderedTrips = getTripsForTimetable(timetable, calendars, config);
+    timetable.stops = getStopsForTimetable(timetable, config);
+    timetable.calendarDates = getCalendarDatesForTimetable(timetable, config);
+    timetable.timetable_label = formatTimetableLabel(timetable);
+    timetable.notes = getTimetableNotesForTimetable(timetable, config);
+    if (config.showMap) {
+      timetable.geojson = getTimetableGeoJSON(timetable, config);
+    }
+    timetable.orderedTrips = filterTrips(timetable);
+    timetable.stops = formatStops(timetable, config);
+    return timetable;
+  });
+  if (config.allowEmptyTimetables) {
+    return formattedTimetables;
+  }
+  return formattedTimetables.filter(
+    (timetable) => timetable.orderedTrips.length > 0
+  );
+};
+function getTimetablePagesForAgency(config) {
+  const timetables = mergeTimetablesWithSameId(getTimetables());
+  if (timetables.length === 0) {
+    return convertRoutesToTimetablePages(config);
+  }
+  const timetablePages = getTimetablePages(
+    {},
+    [],
+    [["timetable_page_id", "ASC"]]
+  );
+  if (timetablePages.length === 0) {
+    return timetables.map(
+      (timetable) => convertTimetableToTimetablePage(timetable, config)
+    );
+  }
+  const routes = getRoutes();
+  return timetablePages.map((timetablePage) => {
+    timetablePage.timetables = sortBy(
+      timetables.filter(
+        (timetable) => timetable.timetable_page_id === timetablePage.timetable_page_id
+      ),
+      "timetable_sequence"
+    );
+    for (const timetable of timetablePage.timetables) {
+      timetable.routes = routes.filter(
+        (route) => timetable.route_ids.includes(route.route_id)
+      );
+    }
+    return timetablePage;
+  });
+}
+var getTimetablePageById = (timetablePageId, config) => {
+  const timetablePages = getTimetablePages({
+    timetable_page_id: timetablePageId
+  });
+  const timetables = mergeTimetablesWithSameId(getTimetables());
+  if (timetablePages.length > 1) {
+    throw new Error(
+      `Multiple timetable_pages found for timetable_page_id=${timetablePageId}`
+    );
+  }
+  if (timetablePages.length === 1) {
+    const timetablePage = timetablePages[0];
+    timetablePage.timetables = sortBy(
+      timetables.filter(
+        (timetable) => timetable.timetable_page_id === timetablePageId
+      ),
+      "timetable_sequence"
+    );
+    for (const timetable of timetablePage.timetables) {
+      timetable.routes = getRoutes({
+        route_id: timetable.route_ids
+      });
+    }
+    return timetablePage;
+  }
+  if (timetables.length > 0) {
+    const timetablePageTimetables = timetables.filter(
+      (timetable) => timetable.timetable_id === timetablePageId
+    );
+    if (timetablePageTimetables.length === 0) {
+      throw new Error(
+        `No timetable found for timetable_page_id=${timetablePageId}`
+      );
+    }
+    return convertTimetableToTimetablePage(timetablePageTimetables[0], config);
+  }
+  let calendarCode;
+  let calendars;
+  let calendarDates;
+  let serviceId;
+  let directionId = "";
+  const parts = timetablePageId.split("|");
+  if (parts.length > 2) {
+    directionId = Number.parseInt(parts.pop(), 10);
+    calendarCode = parts.pop();
+  } else if (parts.length > 1) {
+    directionId = null;
+    calendarCode = parts.pop();
+  }
+  const routeId = parts.join("|");
+  const routes = getRoutes({
+    route_id: routeId
+  });
+  const trips = getTrips(
+    {
+      route_id: routeId,
+      direction_id: directionId
+    },
+    ["trip_headsign", "direction_id"]
+  );
+  const directions = uniqBy(trips, (trip) => trip.direction_id);
+  if (directions.length === 0) {
+    throw new Error(
+      `No trips found for timetable_page_id=${timetablePageId} route_id=${routeId} direction_id=${directionId}`
+    );
+  }
+  if (/^[01]*$/.test(calendarCode)) {
+    calendars = getCalendars({
+      ...calendarCodeToCalendar(calendarCode)
+    });
+  } else {
+    serviceId = calendarCode;
+    calendarDates = getCalendarDates({
+      exception_type: 1,
+      service_id: serviceId
+    });
+  }
+  return convertRouteToTimetablePage(
+    routes[0],
+    directions[0],
+    calendars,
+    calendarDates,
+    config
+  );
+};
+function setDefaultConfig(initialConfig) {
+  const defaults = {
+    allowEmptyTimetables: false,
+    beautify: false,
+    coordinatePrecision: 5,
+    dateFormat: "MMM D, YYYY",
+    daysShortStrings: ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
+    daysStrings: [
+      "Monday",
+      "Tuesday",
+      "Wednesday",
+      "Thursday",
+      "Friday",
+      "Saturday",
+      "Sunday"
+    ],
+    defaultOrientation: "vertical",
+    interpolatedStopSymbol: "\u2022",
+    interpolatedStopText: "Estimated time of arrival",
+    gtfsToHtmlVersion: version,
+    linkStopUrls: false,
+    menuType: "jump",
+    noDropoffSymbol: "\u2021",
+    noDropoffText: "No drop off available",
+    noHead: false,
+    noPickupSymbol: "**",
+    noPickupText: "No pickup available",
+    noServiceSymbol: "-",
+    noServiceText: "No service at this stop",
+    outputFormat: "html",
+    requestDropoffSymbol: "\u2020",
+    requestDropoffText: "Must request drop off",
+    requestPickupSymbol: "***",
+    requestPickupText: "Request stop - call for pickup",
+    serviceNotProvidedOnText: "Service not provided on",
+    serviceProvidedOnText: "Service provided on",
+    showArrivalOnDifference: 0.2,
+    showCalendarExceptions: true,
+    showMap: false,
+    showOnlyTimepoint: false,
+    showRouteTitle: true,
+    showStopCity: false,
+    showStopDescription: false,
+    showStoptimesForRequestStops: true,
+    skipImport: false,
+    sortingAlgorithm: "common",
+    timeFormat: "h:mma",
+    useParentStation: true,
+    verbose: true,
+    zipOutput: false
+  };
+  const config = Object.assign(defaults, initialConfig);
+  if (config.outputFormat === "pdf") {
+    config.noHead = false;
+  }
+  return config;
+}
+function getFormattedTimetablePage(timetablePageId, config) {
+  const timetablePage = getTimetablePageById(
+    timetablePageId,
+    config
+  );
+  const timetableRoutes = getRoutes(
+    {
+      route_id: timetablePage.route_ids
+    },
+    ["agency_id"]
+  );
+  const consolidatedTimetables = formatTimetables(
+    timetablePage.timetables,
+    config
+  );
+  for (const timetable of consolidatedTimetables) {
+    if (isNullOrEmpty(timetable.direction_name)) {
+      timetable.direction_name = getDirectionHeadsignFromTimetable(timetable);
+    }
+    if (!timetable.routes) {
+      timetable.routes = getRoutes({
+        route_id: timetable.route_ids
+      });
+    }
+  }
+  const formattedTimetablePage = {
+    ...timetablePage,
+    consolidatedTimetables,
+    dayList: formatDays(getDaysFromCalendars(consolidatedTimetables), config),
+    dayLists: uniq(
+      consolidatedTimetables.map((timetable) => timetable.dayList)
+    ),
+    route_ids: uniq(flatMap2(consolidatedTimetables, "route_ids")),
+    agency_ids: uniq(compact(timetableRoutes.map((route) => route.agency_id))),
+    filename: timetablePage.filename ?? `${timetablePage.timetable_page_id}.html`
+  };
+  return formattedTimetablePage;
+}
+var generateStats = (timetablePage) => {
+  const routeIds = {};
+  const serviceIds = {};
+  const stats = {
+    stops: 0,
+    trips: 0,
+    routes: 0,
+    calendars: 0
+  };
+  for (const timetable of timetablePage.consolidatedTimetables) {
+    stats.stops += timetable.stops.length;
+    stats.trips += timetable.orderedTrips.length;
+    for (const serviceId of timetable.service_ids) {
+      serviceIds[serviceId] = true;
+    }
+    for (const routeId of timetable.route_ids) {
+      routeIds[routeId] = true;
+    }
+  }
+  stats.routes = size(routeIds);
+  stats.calendars = size(serviceIds);
+  return stats;
+};
+function generateTimetableHTML(timetablePage, config) {
+  const templateVars = {
+    timetablePage,
+    config
+  };
+  return renderTemplate("timetablepage", templateVars, config);
+}
+function generateTimetableCSV(timetable) {
+  const lines = [];
+  lines.push([
+    "",
+    ...timetable.orderedTrips.map(
+      (trip) => formatTripNameForCSV(trip, timetable)
+    )
+  ]);
+  if (timetable.has_continues_from_route) {
+    lines.push([
+      "Continues from route",
+      ...timetable.orderedTrips.map((trip) => formatTripContinuesFrom(trip))
+    ]);
+  }
+  for (const stop of timetable.stops) {
+    lines.push([
+      formatStopName(stop),
+      ...stop.trips.map((stoptime) => stoptime.formatted_time)
+    ]);
+  }
+  if (timetable.has_continues_as_route) {
+    lines.push([
+      "Continues as route",
+      ...timetable.orderedTrips.map((trip) => formatTripContinuesAs(trip))
+    ]);
+  }
+  if (timetable.orientation === "vertical") {
+    return stringify(zip(...lines));
+  }
+  return stringify(lines);
+}
+function generateOverviewHTML(timetablePages, config) {
+  const agencies = getAgencies();
+  if (agencies.length === 0) {
+    throw new Error("No agencies found");
+  }
+  let geojson;
+  if (config.showMap) {
+    geojson = getAgencyGeoJSON(config);
+  }
+  const sortedTimetablePages = sortBy(timetablePages, [
+    (timetablePage) => {
+      if (timetablePage.consolidatedTimetables.length > 0 && timetablePage.consolidatedTimetables[0].routes.length > 0) {
+        return Number.parseInt(
+          timetablePage.consolidatedTimetables[0].routes[0].route_short_name?.replace(
+            /^\D+/g,
+            ""
+          ),
+          10
+        ) || 0;
+      }
+    },
+    (timetablePage) => {
+      if (timetablePage.consolidatedTimetables.length > 0 && timetablePage.consolidatedTimetables[0].routes.length > 0) {
+        return timetablePage.consolidatedTimetables[0].routes[0].route_short_name;
+      }
+    }
+  ]);
+  const templateVars = {
+    agency: {
+      ...first(agencies),
+      geojson
+    },
+    agencies,
+    geojson,
+    config,
+    timetablePages: sortedTimetablePages
+  };
+  return renderTemplate("overview", templateVars, config);
+}
+
+// src/lib/formatters.ts
+function replaceAll(string, mapObject) {
+  const re = new RegExp(Object.keys(mapObject).join("|"), "gi");
+  return string.replace(re, (matched) => mapObject[matched]);
+}
+function isNullOrEmpty(value) {
+  return value === null || value === "";
+}
+function formatDate(date, dateFormat) {
+  if (date.holiday_name) {
+    return date.holiday_name;
+  }
+  return moment3(date.date, "YYYYMMDD").format(dateFormat);
+}
+function timeToSeconds(time) {
+  return moment3.duration(time).asSeconds();
+}
+function formatStopTime(stoptime, timetable, config) {
+  stoptime.classes = [];
+  if (stoptime.type === "arrival" && stoptime.arrival_time) {
+    const arrivalTime = fromGTFSTime(stoptime.arrival_time);
+    stoptime.formatted_time = arrivalTime.format(config.timeFormat);
+    stoptime.classes.push(arrivalTime.format("a"));
+  } else if (stoptime.type === "departure" && stoptime.departure_time) {
+    const departureTime = fromGTFSTime(stoptime.departure_time);
+    stoptime.formatted_time = departureTime.format(config.timeFormat);
+    stoptime.classes.push(departureTime.format("a"));
+  }
+  if (stoptime.pickup_type === 1) {
+    stoptime.noPickup = true;
+    stoptime.classes.push("no-pickup");
+    if (timetable.noPickupSymbol !== null) {
+      timetable.noPickupSymbolUsed = true;
+    }
+  } else if (stoptime.pickup_type === 2 || stoptime.pickup_type === 3) {
+    stoptime.requestPickup = true;
+    stoptime.classes.push("request-pickup");
+    if (timetable.requestPickupSymbol !== null) {
+      timetable.requestPickupSymbolUsed = true;
+    }
+  }
+  if (stoptime.drop_off_type === 1) {
+    stoptime.noDropoff = true;
+    stoptime.classes.push("no-drop-off");
+    if (timetable.noDropoffSymbol !== null) {
+      timetable.noDropoffSymbolUsed = true;
+    }
+  } else if (stoptime.drop_off_type === 2 || stoptime.drop_off_type === 3) {
+    stoptime.requestDropoff = true;
+    stoptime.classes.push("request-drop-off");
+    if (timetable.requestDropoffSymbol !== null) {
+      timetable.requestDropoffSymbolUsed = true;
+    }
+  }
+  if (stoptime.timepoint === 0 || stoptime.departure_time === "") {
+    stoptime.interpolated = true;
+    stoptime.classes.push("interpolated");
+    if (timetable.interpolatedStopSymbol !== null) {
+      timetable.interpolatedStopSymbolUsed = true;
+    }
+  }
+  if (stoptime.timepoint === null && stoptime.departure_time === null) {
+    stoptime.skipped = true;
+    stoptime.classes.push("skipped");
+    if (timetable.noServiceSymbol !== null) {
+      timetable.noServiceSymbolUsed = true;
+    }
+  }
+  if (stoptime.timepoint === 1) {
+    stoptime.classes.push("timepoint");
+  }
+  return stoptime;
+}
+function filterHourlyTimes(stops) {
+  const firstStopTimes = [];
+  const firstTripMinutes = minutesAfterMidnight(stops[0].trips[0].arrival_time);
+  for (const trip of stops[0].trips) {
+    const minutes = minutesAfterMidnight(trip.arrival_time);
+    if (minutes >= firstTripMinutes + 60) {
+      break;
+    }
+    firstStopTimes.push(fromGTFSTime(trip.arrival_time));
+  }
+  const firstStopTimesAndIndex = firstStopTimes.map((time, idx) => ({
+    idx,
+    time
+  }));
+  const sortedFirstStopTimesAndIndex = sortBy2(
+    firstStopTimesAndIndex,
+    (item) => Number.parseInt(item.time.format("m"), 10)
+  );
+  return stops.map((stop) => {
+    stop.hourlyTimes = sortedFirstStopTimesAndIndex.map(
+      (item) => fromGTFSTime(stop.trips[item.idx].arrival_time).format(":mm")
+    );
+    return stop;
+  });
+}
+var days = [
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday"
+];
+function formatDays(calendar, config) {
+  const daysShort = config.daysShortStrings;
+  let daysInARow = 0;
+  let dayString = "";
+  if (!calendar) {
+    return "";
+  }
+  for (let i = 0; i <= 6; i += 1) {
+    const currentDayOperating = calendar[days[i]] === 1;
+    const previousDayOperating = i > 0 ? calendar[days[i - 1]] === 1 : false;
+    const nextDayOperating = i < 6 ? calendar[days[i + 1]] === 1 : false;
+    if (currentDayOperating) {
+      if (dayString.length > 0) {
+        if (!previousDayOperating) {
+          dayString += ", ";
+        } else if (daysInARow === 1) {
+          dayString += "-";
+        }
+      }
+      daysInARow += 1;
+      if (dayString.length === 0 || !nextDayOperating || i === 6 || !previousDayOperating) {
+        dayString += daysShort[i];
+      }
+    } else {
+      daysInARow = 0;
+    }
+  }
+  if (dayString.length === 0) {
+    dayString = "No regular service days";
+  }
+  return dayString;
+}
+function formatDaysLong(dayList, config) {
+  const mapObject = zipObject(config.daysShortStrings, config.daysStrings);
+  return replaceAll(dayList, mapObject);
+}
+function formatTrip(trip, timetable, calendars, config) {
+  trip.calendar = find2(calendars, {
+    service_id: trip.service_id
+  });
+  trip.dayList = formatDays(trip.calendar, config);
+  trip.dayListLong = formatDaysLong(trip.dayList, config);
+  if (timetable.routes.length === 1) {
+    trip.route_short_name = timetable.routes[0].route_short_name;
+  } else {
+    const route = timetable.routes.find(
+      (route2) => route2.route_id === trip.route_id
+    );
+    trip.route_short_name = route.route_short_name;
+  }
+  return trip;
+}
+function formatFrequency(frequency, config) {
+  const startTime = fromGTFSTime(frequency.start_time);
+  const endTime = fromGTFSTime(frequency.end_time);
+  const headway = moment3.duration(frequency.headway_secs, "seconds");
+  frequency.start_formatted_time = startTime.format(config.timeFormat);
+  frequency.end_formatted_time = endTime.format(config.timeFormat);
+  frequency.headway_min = Math.round(headway.asMinutes());
+  return frequency;
+}
+function formatTimetableId(timetable) {
+  let timetableId = `${timetable.route_ids.join("_")}|${calendarToCalendarCode(
+    timetable
+  )}`;
+  if (!isNullOrEmpty(timetable.direction_id)) {
+    timetableId += `|${timetable.direction_id}`;
+  }
+  return timetableId;
+}
+function createEmptyStoptime(stopId, tripId) {
+  return {
+    id: null,
+    trip_id: tripId,
+    arrival_time: null,
+    departure_time: null,
+    stop_id: stopId,
+    stop_sequence: null,
+    stop_headsign: null,
+    pickup_type: null,
+    drop_off_type: null,
+    continuous_pickup: null,
+    continuous_drop_off: null,
+    shape_dist_traveled: null,
+    timepoint: null
+  };
+}
+function formatStops(timetable, config) {
+  for (const trip of timetable.orderedTrips) {
+    let stopIndex = -1;
+    for (const [idx, stoptime] of trip.stoptimes.entries()) {
+      const stop = find2(timetable.stops, (st, idx2) => {
+        if (st.stop_id === stoptime.stop_id && idx2 > stopIndex) {
+          stopIndex = idx2;
+          return true;
+        }
+        return false;
+      });
+      if (!stop) {
+        continue;
+      }
+      if (idx === 0) {
+        stoptime.drop_off_type = 0;
+      }
+      if (idx === trip.stoptimes.length - 1) {
+        stoptime.pickup_type = 0;
+      }
+      if (stop.type === "arrival" && idx < trip.stoptimes.length - 1) {
+        const departureStoptime = clone(stoptime);
+        departureStoptime.type = "departure";
+        timetable.stops[stopIndex + 1].trips.push(
+          formatStopTime(departureStoptime, timetable, config)
+        );
+      }
+      if (!(stop.type === "arrival" && idx === 0)) {
+        stoptime.type = "arrival";
+        stop.trips.push(formatStopTime(stoptime, timetable, config));
+      }
+    }
+    for (const stop of timetable.stops) {
+      const lastStopTime = last2(stop.trips);
+      if (!lastStopTime || lastStopTime.trip_id !== trip.trip_id) {
+        stop.trips.push(
+          formatStopTime(
+            createEmptyStoptime(stop.stop_id, trip.trip_id),
+            timetable,
+            config
+          )
+        );
+      }
+    }
+  }
+  if (timetable.orientation === "hourly") {
+    timetable.stops = filterHourlyTimes(timetable.stops);
+  }
+  for (const stop of timetable.stops) {
+    stop.is_timepoint = stop.trips.some((stoptime) => isTimepoint(stoptime));
+  }
+  return timetable.stops;
+}
+function formatStopName(stop) {
+  return `${stop.stop_name}${stop.type === "arrival" ? " (Arrival)" : stop.type === "departure" ? " (Departure)" : ""}`;
+}
+function formatTripContinuesFrom(trip) {
+  return trip.continues_from_route ? trip.continues_from_route.route.route_short_name : "";
+}
+function formatTripContinuesAs(trip) {
+  return trip.continues_as_route ? trip.continues_as_route.route.route_short_name : "";
+}
+function resetStoptimesToMidnight(trip) {
+  const offsetSeconds = secondsAfterMidnight(
+    first2(trip.stoptimes).departure_time
+  );
+  if (offsetSeconds > 0) {
+    for (const stoptime of trip.stoptimes) {
+      stoptime.departure_time = toGTFSTime(
+        fromGTFSTime(stoptime.departure_time).subtract(
+          offsetSeconds,
+          "seconds"
+        )
+      );
+      stoptime.arrival_time = toGTFSTime(
+        fromGTFSTime(stoptime.arrival_time).subtract(offsetSeconds, "seconds")
+      );
+    }
+  }
+  return trip;
+}
+function updateStoptimesByOffset(trip, offsetSeconds) {
+  return trip.stoptimes.map((stoptime) => {
+    delete stoptime._id;
+    stoptime.departure_time = updateTimeByOffset(
+      stoptime.departure_time,
+      offsetSeconds
+    );
+    stoptime.arrival_time = updateTimeByOffset(
+      stoptime.arrival_time,
+      offsetSeconds
+    );
+    stoptime.trip_id = trip.trip_id;
+    return stoptime;
+  });
+}
+function formatRouteColor(route) {
+  return route.route_color ? `#${route.route_color}` : "#000000";
+}
+function formatRouteTextColor(route) {
+  return route.route_text_color ? `#${route.route_text_color}` : "#FFFFFF";
+}
+function formatTimetableLabel(timetable) {
+  if (!isNullOrEmpty(timetable.timetable_label)) {
+    return timetable.timetable_label;
+  }
+  let timetableLabel = "";
+  if (timetable.routes && timetable.routes.length > 0) {
+    timetableLabel += "Route ";
+    if (!isNullOrEmpty(timetable.routes[0].route_short_name)) {
+      timetableLabel += timetable.routes[0].route_short_name;
+    } else if (!isNullOrEmpty(timetable.routes[0].route_long_name)) {
+      timetableLabel += timetable.routes[0].route_long_name;
+    }
+  }
+  if (timetable.stops && timetable.stops.length > 0) {
+    const firstStop = timetable.stops[0].stop_name;
+    const lastStop = timetable.stops[timetable.stops.length - 1].stop_name;
+    if (firstStop === lastStop) {
+      if (!isNullOrEmpty(timetable.routes[0].route_long_name)) {
+        timetableLabel += ` - ${timetable.routes[0].route_long_name}`;
+      }
+      timetableLabel += " - Loop";
+    } else {
+      timetableLabel += ` - ${firstStop} to ${lastStop}`;
+    }
+  } else if (timetable.direction_name !== null) {
+    timetableLabel += ` to ${timetable.direction_name}`;
+  }
+  return timetableLabel;
+}
+function mergeTimetablesWithSameId(timetables) {
+  if (timetables.length === 0) {
+    return [];
+  }
+  const mergedTimetables = groupBy2(timetables, "timetable_id");
+  return Object.values(mergedTimetables).map((timetableGroup) => {
+    const mergedTimetable = omit(timetableGroup[0], "route_id");
+    mergedTimetable.route_ids = timetableGroup.map(
+      (timetable) => timetable.route_id
+    );
+    return mergedTimetable;
+  });
+}
+
+// src/lib/file-utils.ts
+function getTemplatePath(templateFileName, config) {
+  let fullTemplateFileName = templateFileName;
+  if (config.noHead !== true) {
+    fullTemplateFileName += "_full";
+  }
+  const templatePath = config.templatePath === void 0 ? path.join(fileURLToPath(import.meta.url), "../../../views/default") : untildify(config.templatePath);
+  return path.join(templatePath, `${fullTemplateFileName}.pug`);
+}
+async function prepDirectory(exportPath) {
+  await rm(exportPath, { recursive: true, force: true });
+  try {
+    await mkdir(exportPath, { recursive: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(
+        `Unable to write to ${exportPath}. Try running this command from a writable directory.`
+      );
+    }
+    throw error;
+  }
+}
+function copyStaticAssets(config, exportPath) {
+  const staticAssetPath = config.templatePath === void 0 ? path.join(fileURLToPath(import.meta.url), "../../../views/default") : untildify(config.templatePath);
+  copydir.sync(path.join(staticAssetPath, "css"), path.join(exportPath, "css"));
+  copydir.sync(path.join(staticAssetPath, "js"), path.join(exportPath, "js"));
+}
+function zipFolder(exportPath) {
+  const output = createWriteStream(path.join(exportPath, "timetables.zip"));
+  const archive = archiver("zip");
+  return new Promise((resolve, reject) => {
+    output.on("close", resolve);
+    archive.on("error", reject);
+    archive.pipe(output);
+    archive.glob("**/*.{txt,css,js,html}", {
+      cwd: exportPath
+    });
+    archive.finalize();
+  });
+}
+function generateFileName(timetable, config, extension = "html") {
+  let filename = timetable.timetable_id;
+  for (const route of timetable.routes) {
+    filename += isNullOrEmpty(route.route_short_name) ? `_${route.route_long_name.replace(/\s/g, "-")}` : `_${route.route_short_name.replace(/\s/g, "-")}`;
+  }
+  if (!isNullOrEmpty(timetable.direction_id)) {
+    filename += `_${timetable.direction_id}`;
+  }
+  filename += `_${formatDays(timetable, config).replace(/\s/g, "")}.${extension}`;
+  return sanitize(filename).toLowerCase();
+}
+function generateFolderName(timetablePage) {
+  const timetable = timetablePage.consolidatedTimetables[0];
+  if (!timetable.start_date || !timetable.end_date) {
+    return "timetables";
+  }
+  return sanitize(`${timetable.start_date}-${timetable.end_date}`);
+}
+async function renderTemplate(templateFileName, templateVars, config) {
+  const templatePath = getTemplatePath(templateFileName, config);
+  const html = await renderFile(templatePath, {
+    _,
+    md: (text) => insane(marked.parseInline(text)),
+    ...template_functions_exports,
+    formatRouteColor,
+    formatRouteTextColor,
+    ...templateVars
+  });
+  if (config.beautify === true) {
+    return beautify.html_beautify(html, {
+      indent_size: 2
+    });
+  }
+  return html;
+}
+async function renderPdf(htmlPath) {
+  const pdfPath = htmlPath.replace(/html$/, "pdf");
+  const browser = await puppeteer.launch();
+  const page = await browser.newPage();
+  await page.emulateMediaType("screen");
+  await page.goto(`file://${htmlPath}`, {
+    waitUntil: "networkidle0"
+  });
+  await page.pdf({
+    path: pdfPath
+  });
+  await browser.close();
+}
+
+// src/lib/log-utils.ts
+import { clearLine, cursorTo } from "node:readline";
+import { noop } from "lodash-es";
+import * as colors from "yoctocolors";
+import { getFeedInfo } from "gtfs";
+import Table from "cli-table";
+function generateLogText(outputStats, config) {
+  const feedInfo = getFeedInfo();
+  const feedVersion = feedInfo.length > 0 && feedInfo[0].feed_version ? feedInfo[0].feed_version : "Unknown";
+  const logText = [
+    `Feed Version: ${feedVersion}`,
+    `GTFS-to-HTML Version: ${config.gtfsToHtmlVersion}`,
+    `Date Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `Timetable Page Count: ${outputStats.timetablePages}`,
+    `Timetable Count: ${outputStats.timetables}`,
+    `Calendar Service ID Count: ${outputStats.calendars}`,
+    `Route Count: ${outputStats.routes}`,
+    `Trip Count: ${outputStats.trips}`,
+    `Stop Count: ${outputStats.stops}`
+  ];
+  for (const agency of config.agencies) {
+    if (agency.url) {
+      logText.push(`Source: ${agency.url}`);
+    } else if (agency.path) {
+      logText.push(`Source: ${agency.path}`);
+    }
+  }
+  if (outputStats.warnings.length > 0) {
+    logText.push("", "Warnings:", ...outputStats.warnings);
+  }
+  return logText.join("\n");
+}
+function log(config) {
+  if (config.verbose === false) {
+    return noop;
+  }
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text, overwrite) => {
+    if (overwrite === true && process.stdout.isTTY) {
+      clearLine(process.stdout, 0);
+      cursorTo(process.stdout, 0);
+    } else {
+      process.stdout.write("\n");
+    }
+    process.stdout.write(text);
+  };
+}
+function logWarning(config) {
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text) => {
+    process.stdout.write(`
+${formatWarning(text)}
+`);
+  };
+}
+function logError(config) {
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text) => {
+    process.stdout.write(`
+${formatError(text)}
+`);
+  };
+}
+function formatWarning(text) {
+  const warningMessage = `${colors.underline("Warning")}: ${text}`;
+  return colors.yellow(warningMessage);
+}
+function formatError(error) {
+  const messageText = error instanceof Error ? error.message : error;
+  const errorMessage = `${colors.underline("Error")}: ${messageText.replace(
+    "Error: ",
+    ""
+  )}`;
+  return colors.red(errorMessage);
+}
+function logStats(stats, config) {
+  if (config.logFunction) {
+    return;
+  }
+  const table = new Table({
+    colWidths: [40, 20],
+    head: ["Item", "Count"]
+  });
+  table.push(
+    ["\u{1F4C4} Timetable Pages", stats.timetablePages],
+    ["\u{1F551} Timetables", stats.timetables],
+    ["\u{1F4C5} Calendar Service IDs", stats.calendars],
+    ["\u{1F504} Routes", stats.routes],
+    ["\u{1F68D} Trips", stats.trips],
+    ["\u{1F6D1} Stops", stats.stops],
+    ["\u26D4\uFE0F Warnings", stats.warnings.length]
+  );
+  config.log(table.toString());
+}
+var generateProgressBarString = (barTotal, barProgress, size2 = 40) => {
+  const line = "-";
+  const slider = "=";
+  if (!barTotal) {
+    throw new Error("Total value is either not provided or invalid");
+  }
+  if (!barProgress && barProgress !== 0) {
+    throw new Error("Current value is either not provided or invalid");
+  }
+  if (isNaN(barTotal)) {
+    throw new Error("Total value is not an integer");
+  }
+  if (isNaN(barProgress)) {
+    throw new Error("Current value is not an integer");
+  }
+  if (isNaN(size2)) {
+    throw new Error("Size is not an integer");
+  }
+  if (barProgress > barTotal) {
+    return slider.repeat(size2 + 2);
+  }
+  const percentage = barProgress / barTotal;
+  const progress = Math.round(size2 * percentage);
+  const emptyProgress = size2 - progress;
+  const progressText = slider.repeat(progress);
+  const emptyProgressText = line.repeat(emptyProgress);
+  return progressText + emptyProgressText;
+};
+function progressBar(formatString, barTotal, config) {
+  let barProgress = 0;
+  if (config.verbose === false) {
+    return {
+      increment: noop,
+      interrupt: noop
+    };
+  }
+  if (barTotal === 0) {
+    return null;
+  }
+  const renderProgressString = () => formatString.replace("{value}", barProgress).replace("{total}", barTotal).replace("{bar}", generateProgressBarString(barTotal, barProgress));
+  config.log(renderProgressString(), true);
+  return {
+    interrupt(text) {
+      config.logWarning(text);
+      config.log("");
+    },
+    increment() {
+      barProgress += 1;
+      config.log(renderProgressString(), true);
+    }
+  };
+}
+
+// src/lib/gtfs-to-html.ts
+var gtfsToHtml = async (initialConfig) => {
+  const config = setDefaultConfig(initialConfig);
+  const timer = new Timer();
+  config.log = log(config);
+  config.logWarning = logWarning(config);
+  config.logError = logError(config);
+  timer.start();
+  try {
+    openDb2(config);
+  } catch (error) {
+    if (error?.code === "SQLITE_CANTOPEN") {
+      config.logError(
+        `Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists or remove \`sqlitePath\` from config.json.`
+      );
+    }
+    throw error;
+  }
+  if (!config.agencies || config.agencies.length === 0) {
+    throw new Error("No agencies defined in `config.json`");
+  }
+  if (!config.skipImport) {
+    await importGtfs(config);
+  }
+  const agencyKey = config.agencies.map((agency) => agency.agency_key ?? "unknown").join("-");
+  const exportPath = path2.join(process.cwd(), "html", sanitize2(agencyKey));
+  const outputStats = {
+    timetables: 0,
+    timetablePages: 0,
+    calendars: 0,
+    routes: 0,
+    trips: 0,
+    stops: 0,
+    warnings: []
+  };
+  const timetablePages = [];
+  const timetablePageIds = map(
+    getTimetablePagesForAgency(config),
+    "timetable_page_id"
+  );
+  await prepDirectory(exportPath);
+  if (config.noHead !== true && ["html", "pdf"].includes(config.outputFormat)) {
+    copyStaticAssets(config, exportPath);
+  }
+  const bar = progressBar(
+    `${agencyKey}: Generating ${config.outputFormat.toUpperCase()} timetables {bar} {value}/{total}`,
+    timetablePageIds.length,
+    config
+  );
+  for (const timetablePageId of timetablePageIds) {
+    try {
+      const timetablePage = await getFormattedTimetablePage(
+        timetablePageId,
+        config
+      );
+      for (const timetable of timetablePage.timetables) {
+        for (const warning of timetable.warnings) {
+          outputStats.warnings.push(warning);
+          bar?.interrupt(warning);
+        }
+      }
+      if (timetablePage.consolidatedTimetables.length === 0) {
+        throw new Error(
+          `No timetables found for timetable_page_id=${timetablePage.timetable_page_id}`
+        );
+      }
+      outputStats.timetables += timetablePage.consolidatedTimetables.length;
+      outputStats.timetablePages += 1;
+      const datePath = generateFolderName(timetablePage);
+      await mkdir2(path2.join(exportPath, datePath), { recursive: true });
+      config.assetPath = "../";
+      timetablePage.relativePath = path2.join(
+        datePath,
+        sanitize2(timetablePage.filename)
+      );
+      if (config.outputFormat === "csv") {
+        for (const timetable of timetablePage.consolidatedTimetables) {
+          const csv = await generateTimetableCSV(timetable);
+          const csvPath = path2.join(
+            exportPath,
+            datePath,
+            generateFileName(timetable, config, "csv")
+          );
+          await writeFile(csvPath, csv);
+        }
+      } else {
+        const html = await generateTimetableHTML(timetablePage, config);
+        const htmlPath = path2.join(
+          exportPath,
+          datePath,
+          sanitize2(timetablePage.filename)
+        );
+        await writeFile(htmlPath, html);
+        if (config.outputFormat === "pdf") {
+          await renderPdf(htmlPath);
+        }
+      }
+      timetablePages.push(timetablePage);
+      const timetableStats = generateStats(timetablePage);
+      outputStats.stops += timetableStats.stops;
+      outputStats.routes += timetableStats.routes;
+      outputStats.trips += timetableStats.trips;
+      outputStats.calendars += timetableStats.calendars;
+    } catch (error) {
+      outputStats.warnings.push(error?.message);
+      bar?.interrupt(error.message);
+    }
+    bar?.increment();
+  }
+  if (config.outputFormat === "html") {
+    config.assetPath = "";
+    const html = await generateOverviewHTML(timetablePages, config);
+    await writeFile(path2.join(exportPath, "index.html"), html);
+  }
+  const logText = generateLogText(outputStats, config);
+  await writeFile(path2.join(exportPath, "log.txt"), logText);
+  if (config.zipOutput) {
+    await zipFolder(exportPath);
+  }
+  const fullExportPath = path2.join(
+    exportPath,
+    config.zipOutput ? "/timetables.zip" : ""
+  );
+  config.log(
+    `${agencyKey}: ${config.outputFormat.toUpperCase()} timetables created at ${fullExportPath}`
+  );
+  logStats(outputStats, config);
+  const seconds = Math.round(timer.time() / 1e3);
+  config.log(
+    `${agencyKey}: ${config.outputFormat.toUpperCase()} timetable generation required ${seconds} seconds`
+  );
+  timer.stop();
+};
+var gtfs_to_html_default = gtfsToHtml;
+export {
+  gtfs_to_html_default as default
+};
+//# sourceMappingURL=index.js.map