gtfs 4.18.7 → 4.19.1

package/dist/src-DuXcyA_N.js

@@ -0,0 +1,2417 @@
+import { S as tripUpdates, b as vehiclePositions, t as models_exports, v as serviceAlertInformedEntities, x as stopTimeUpdates, y as serviceAlerts } from "./models-9NvwLHlL.js";
+import path from "node:path";
+import { createReadStream, existsSync, lstatSync } from "node:fs";
+import { cp, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { parse } from "csv-parse";
+import stripBomStream from "strip-bom-stream";
+import { temporaryDirectory } from "tempy";
+import mapSeries from "promise-map-series";
+import fs from "fs";
+import Database from "better-sqlite3";
+import { homedir } from "node:os";
+import { cloneDeep, compact, filter, get, groupBy, last, noop, omit, omitBy, orderBy, pick, snakeCase, sortBy, without } from "lodash-es";
+import sanitize from "sanitize-filename";
+import StreamZip from "node-stream-zip";
+import { clearLine, cursorTo } from "node:readline";
+import * as colors from "yoctocolors";
+import { feature, featureCollection } from "@turf/helpers";
+import GtfsRealtimeBindings from "gtfs-realtime-bindings";
+import sqlString from "sqlstring-sqlite";
+import Long from "long";
+import { stringify } from "csv-stringify";
+
+//#region src/lib/log-utils.ts
+/**
+* Creates a logging function based on configuration settings
+* @param {Config} config - Configuration object containing logging preferences
+* @returns {LogFunction} Logging function that writes to stdout, or noop if verbose is false
+* @example
+* const logger = log({ verbose: true });
+* logger('Processing...', true); // Overwrites current line
+* logger('Done!'); // Writes on new line
+*/
+function log(config) {
+	if (config.verbose === false) return noop;
+	if (config.logFunction) return config.logFunction;
+	return (text, overwrite = false) => {
+		if (overwrite && process.stdout.isTTY) {
+			clearLine(process.stdout, 0);
+			cursorTo(process.stdout, 0);
+		} else process.stdout.write("\n");
+		process.stdout.write(text);
+	};
+}
+/**
+* Creates a warning logging function
+* @param {Config} config - Configuration object containing logging preferences
+* @returns {(text: string) => void} Function that logs formatted warning messages
+* @example
+* const warnLogger = logWarning(config);
+* warnLogger('Resource not found'); // Outputs yellow warning message
+*/
+function logWarning(config) {
+	if (config.logFunction) return config.logFunction;
+	return (text) => {
+		process.stdout.write(`\n${formatWarning(text)}\n`);
+	};
+}
+/**
+* Creates an error logging function
+* @param {Config} config - Configuration object containing logging preferences
+* @returns {(text: string) => void} Function that logs formatted error messages
+* @example
+* const errorLogger = logError(config);
+* errorLogger('Failed to connect'); // Outputs red error message
+*/
+function logError(config) {
+	if (config.logFunction) return config.logFunction;
+	return (text) => {
+		process.stdout.write(`\n${formatError(text)}\n`);
+	};
+}
+/**
+* Formats warning text with yellow color and underline
+* @param {string} text - The warning message to format
+* @returns {string} Formatted warning message in yellow with underlined "Warning" prefix
+* @example
+* const formattedWarning = formatWarning('Resource not found');
+* console.log(formattedWarning); // Yellow "Warning: Resource not found"
+*/
+function formatWarning(text) {
+	return colors.yellow(`${colors.underline("Warning")}: ${text}`);
+}
+/**
+* Formats error text with red color and underline
+* @param {Error | string} error - The error object or message to format
+* @returns {string} Formatted error message in red with underlined "Error" prefix
+* @example
+* const formattedError = formatError(new Error('Connection failed'));
+* console.log(formattedError); // Red "Error: Connection failed"
+*/
+function formatError(error) {
+	const cleanMessage = (error instanceof Error ? error.message : error).replace(/^Error:\s*/i, "");
+	return colors.red(`${colors.underline("Error")}: ${cleanMessage}`);
+}
+
+//#endregion
+//#region src/lib/file-utils.ts
+const homeDirectory = homedir();
+/**
+* Attempts to parse and load configuration from various sources
+* Priority: 1. CLI config path 2. CLI direct args 3. ./config.json
+* @param {ConfigArgs} argv - Command line arguments
+* @throws {Error} If configuration cannot be found or parsed
+* @returns {Promise<Record<string, any>>} Parsed configuration object
+* @example
+* const config = await getConfig({ configPath: './my-config.json' });
+*/
+async function getConfig(argv) {
+	let config;
+	let data;
+	try {
+		if (argv.configPath) {
+			data = await readFile(path.resolve(untildify(argv.configPath)), "utf8");
+			config = Object.assign(JSON.parse(data), argv);
+		} else if (argv.gtfsPath || argv.gtfsUrl || argv.sqlitePath) config = {
+			agencies: [...argv.gtfsPath ? [{ path: argv.gtfsPath }] : [], ...argv.gtfsUrl ? [{ url: argv.gtfsUrl }] : []],
+			...omit(argv, ["path", "url"])
+		};
+		else if (existsSync(path.resolve("./config.json"))) {
+			data = await readFile(path.resolve("./config.json"), "utf8");
+			config = Object.assign(JSON.parse(data), argv);
+			log(config)("Using configuration from ./config.json");
+		} else throw new Error("Cannot find configuration file. Use config-sample.json as a starting point, pass --configPath option.");
+		return config;
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new Error(`Cannot parse configuration file. Check to ensure that it is valid JSON. Error: ${error.message}`, { cause: error });
+		throw error;
+	}
+}
+/**
+* Prepares a directory for saving files by clearing its contents
+* @param {string} exportPath - Path to the directory to prepare
+* @returns {Promise<void>}
+* @example
+* await prepDirectory('./output');
+*/
+async function prepDirectory(exportPath) {
+	await rm(exportPath, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(exportPath, { recursive: true });
+}
+/**
+* Extracts contents of a zip file to specified directory
+* @param {string} zipfilePath - Path to the zip file
+* @param {string} exportPath - Directory to extract contents to
+* @returns {Promise<void>}
+* @throws {Error} If zip file cannot be opened or extracted
+* @example
+* await unzip('./data.zip', './extracted');
+*/
+async function unzip(zipfilePath, exportPath) {
+	try {
+		const zip = new StreamZip.async({ file: zipfilePath });
+		await zip.extract(null, exportPath);
+		await zip.close();
+	} catch (error) {
+		throw new Error(`Failed to extract zip file: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
+	}
+}
+/**
+* Generates a safe folder name from input string
+* Converts to snake_case and removes unsafe characters
+* @param {string} folderName - Input string to convert to folder name
+* @returns {string} Sanitized folder name
+* @example
+* generateFolderName('My Folder!') // returns 'my_folder'
+*/
+function generateFolderName(folderName) {
+	if (!folderName || typeof folderName !== "string") throw new Error("Folder name must be a non-empty string");
+	return snakeCase(sanitize(folderName));
+}
+/**
+* Converts a tilde path to a full path
+* @param pathWithTilde The path to convert
+* @returns The full path
+*/
+function untildify(pathWithTilde) {
+	return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+
+//#endregion
+//#region src/lib/errors.ts
+let GtfsErrorCategory = /* @__PURE__ */ function(GtfsErrorCategory) {
+	GtfsErrorCategory["CONFIG"] = "config";
+	GtfsErrorCategory["DOWNLOAD"] = "download";
+	GtfsErrorCategory["ZIP"] = "zip";
+	GtfsErrorCategory["VALIDATION"] = "validation";
+	GtfsErrorCategory["DATABASE"] = "database";
+	GtfsErrorCategory["PARSE"] = "parse";
+	GtfsErrorCategory["QUERY"] = "query";
+	GtfsErrorCategory["INTERNAL"] = "internal";
+	return GtfsErrorCategory;
+}({});
+/**
+* Error codes are a public API contract and must remain stable across
+* minor/patch releases.
+*/
+let GtfsErrorCode = /* @__PURE__ */ function(GtfsErrorCode) {
+	GtfsErrorCode["GTFS_DOWNLOAD_HTTP"] = "GTFS_DOWNLOAD_HTTP";
+	GtfsErrorCode["GTFS_DOWNLOAD_FAILED"] = "GTFS_DOWNLOAD_FAILED";
+	GtfsErrorCode["GTFS_ZIP_INVALID"] = "GTFS_ZIP_INVALID";
+	GtfsErrorCode["GTFS_REQUIRED_FIELD_MISSING"] = "GTFS_REQUIRED_FIELD_MISSING";
+	GtfsErrorCode["GTFS_INVALID_DATE"] = "GTFS_INVALID_DATE";
+	GtfsErrorCode["GTFS_CONFIG_INVALID"] = "GTFS_CONFIG_INVALID";
+	GtfsErrorCode["DB_OPEN_FAILED"] = "DB_OPEN_FAILED";
+	GtfsErrorCode["GTFS_DB_OPERATION_FAILED"] = "GTFS_DB_OPERATION_FAILED";
+	GtfsErrorCode["GTFS_JSON_INVALID"] = "GTFS_JSON_INVALID";
+	GtfsErrorCode["GTFS_UNSUPPORTED_FILE_TYPE"] = "GTFS_UNSUPPORTED_FILE_TYPE";
+	GtfsErrorCode["GTFS_CSV_PARSE_FAILED"] = "GTFS_CSV_PARSE_FAILED";
+	GtfsErrorCode["GTFS_QUERY_INVALID"] = "GTFS_QUERY_INVALID";
+	return GtfsErrorCode;
+}({});
+let GtfsWarningCode = /* @__PURE__ */ function(GtfsWarningCode) {
+	GtfsWarningCode["GTFS_DUPLICATE_PRIMARY_KEY"] = "GTFS_DUPLICATE_PRIMARY_KEY";
+	return GtfsWarningCode;
+}({});
+var GtfsError = class extends Error {
+	code;
+	category;
+	isOperational;
+	statusCode;
+	details;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "GtfsError";
+		this.code = options.code;
+		this.category = options.category;
+		this.isOperational = options.isOperational ?? true;
+		this.statusCode = options.statusCode;
+		this.details = options.details;
+	}
+};
+function isGtfsError(error) {
+	if (!error || typeof error !== "object") return false;
+	const candidate = error;
+	return candidate.name === "GtfsError" && typeof candidate.message === "string" && typeof candidate.code === "string" && typeof candidate.category === "string" && typeof candidate.isOperational === "boolean";
+}
+function isGtfsValidationError(error) {
+	return isGtfsError(error) && error.category === "validation";
+}
+function toGtfsError(error, fallback) {
+	if (isGtfsError(error)) return error;
+	return new GtfsError(fallback.message, {
+		...fallback,
+		cause: error
+	});
+}
+function createImportReport() {
+	return {
+		errors: [],
+		warnings: [],
+		errorCountsByCode: {},
+		warningCountsByCode: {}
+	};
+}
+function addImportError(report, error) {
+	report.errors.push(error);
+	report.errorCountsByCode[error.code] = (report.errorCountsByCode[error.code] ?? 0) + 1;
+}
+function addImportWarning(report, warning) {
+	report.warnings.push(warning);
+	report.warningCountsByCode[warning.code] = (report.warningCountsByCode[warning.code] ?? 0) + 1;
+}
+function formatGtfsError(error, options = { verbosity: "developer" }) {
+	if (!isGtfsError(error)) {
+		const message = error instanceof Error ? error.message : String(error);
+		return options.verbosity === "user" ? message : `UNKNOWN_ERROR: ${message}`;
+	}
+	if (options.verbosity === "user") return error.message;
+	return [
+		`${error.code}: ${error.message}`,
+		`category=${error.category}`,
+		error.statusCode !== void 0 ? `statusCode=${error.statusCode}` : null,
+		error.details ? `details=${JSON.stringify(error.details)}` : null
+	].filter(Boolean).join(" | ");
+}
+
+//#endregion
+//#region src/lib/db.ts
+const dbs = {};
+function setupDb(sqlitePath) {
+	const db = new Database(untildify(sqlitePath));
+	db.pragma("journal_mode = OFF");
+	db.pragma("synchronous = OFF");
+	db.pragma("temp_store = MEMORY");
+	dbs[sqlitePath] = db;
+	return db;
+}
+function openDb(config = null) {
+	if (config) {
+		const { sqlitePath = ":memory:", db } = config;
+		if (db) return db;
+		if (dbs[sqlitePath]) return dbs[sqlitePath];
+		return setupDb(sqlitePath);
+	}
+	if (Object.keys(dbs).length === 0) return setupDb(":memory:");
+	if (Object.keys(dbs).length === 1) return dbs[Object.keys(dbs)[0]];
+	if (Object.keys(dbs).length > 1) throw new GtfsError("Multiple databases open, please specify which one to use.", {
+		code: "GTFS_DB_OPERATION_FAILED",
+		category: "database",
+		details: { openDatabaseCount: Object.keys(dbs).length }
+	});
+	throw new GtfsError("Unable to find database connection.", {
+		code: "GTFS_DB_OPERATION_FAILED",
+		category: "database"
+	});
+}
+function closeDb(db = null) {
+	if (Object.keys(dbs).length === 0) throw new GtfsError("No database connection. Call `openDb(config)` before using any methods.", {
+		code: "GTFS_DB_OPERATION_FAILED",
+		category: "database"
+	});
+	if (!db) {
+		if (Object.keys(dbs).length > 1) throw new GtfsError("Multiple database connections. Pass the db you want to close as a parameter to `closeDb`.", {
+			code: "GTFS_DB_OPERATION_FAILED",
+			category: "database",
+			details: { openDatabaseCount: Object.keys(dbs).length }
+		});
+		db = dbs[Object.keys(dbs)[0]];
+	}
+	db.close();
+	delete dbs[db.name];
+}
+function deleteDb(db = null) {
+	if (Object.keys(dbs).length === 0) throw new GtfsError("No database connection. Call `openDb(config)` before using any methods.", {
+		code: "GTFS_DB_OPERATION_FAILED",
+		category: "database"
+	});
+	if (!db) {
+		if (Object.keys(dbs).length > 1) throw new GtfsError("Multiple database connections. Pass the db you want to delete as a parameter to `deleteDb`.", {
+			code: "GTFS_DB_OPERATION_FAILED",
+			category: "database",
+			details: { openDatabaseCount: Object.keys(dbs).length }
+		});
+		db = dbs[Object.keys(dbs)[0]];
+	}
+	db.close();
+	if (db.name !== ":memory:") fs.unlinkSync(db.name);
+	delete dbs[db.name];
+}
+
+//#endregion
+//#region src/lib/geojson-utils.ts
+/**
+* Validates if a string is valid JSON
+* @param {string} string - The string to validate as JSON
+* @returns {boolean} True if string is valid JSON, false otherwise
+* @example
+* isValidJSON('{"key": "value"}') // returns true
+* isValidJSON('invalid json') // returns false
+*/
+function isValidJSON(string) {
+	try {
+		JSON.parse(string);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Validates if an array of positions forms a valid LineString
+* @param {Position[]} [lineString] - Array of coordinate pairs
+* @returns {boolean} True if lineString is valid, false otherwise
+*/
+function isValidLineString(lineString) {
+	if (!lineString || lineString.length <= 1) return false;
+	if (lineString.length === 2) {
+		const [[x1, y1], [x2, y2]] = lineString;
+		return !(x1 === x2 && y1 === y2);
+	}
+	return true;
+}
+/**
+* Consolidates shape groups into unique line segments
+* @param {Shape[][]} shapeGroups - Array of shape point groups
+* @returns {Position[][]} Array of consolidated line strings
+*/
+function consolidateShapes(shapeGroups) {
+	const keys = /* @__PURE__ */ new Set();
+	const segmentsArray = shapeGroups.map((shapes) => shapes.reduce((memo, point, idx) => {
+		if (idx > 0) {
+			const prevPoint = shapes[idx - 1];
+			memo.push([[prevPoint.shape_pt_lon, prevPoint.shape_pt_lat], [point.shape_pt_lon, point.shape_pt_lat]]);
+		}
+		return memo;
+	}, []));
+	const consolidatedLineStrings = [];
+	for (const segments of segmentsArray) {
+		consolidatedLineStrings.push([]);
+		for (const segment of segments) {
+			const key1 = segment.flat().join(",");
+			const key2 = segment.reverse().flat().join(",");
+			const currentLine = last(consolidatedLineStrings);
+			if (!currentLine || keys.has(key1) || keys.has(key2)) {
+				consolidatedLineStrings.push([]);
+				continue;
+			}
+			if (currentLine.length === 0) currentLine.push(segment[0]);
+			currentLine.push(segment[1]);
+			keys.add(key1);
+			keys.add(key2);
+		}
+	}
+	return filter(consolidatedLineStrings, isValidLineString);
+}
+/**
+* Formats a color string to hex format
+* @param {string | null | undefined} color - Color string to format
+* @returns {string | undefined} Formatted hex color or undefined
+* @example
+* formatHexColor('FF0000') // returns '#FF0000'
+*/
+function formatHexColor(color) {
+	if (!color) return void 0;
+	return `#${color}`;
+}
+/**
+* Formats properties object by cleaning null values and formatting colors
+* @param {Record<string, unknown>} properties - Properties object to format
+* @returns {Record<string, unknown>} Formatted properties object
+*/
+function formatProperties(properties) {
+	const formattedProperties = cloneDeep(omitBy(properties, (value) => value == null));
+	const formattedRouteColor = formatHexColor(properties.route_color);
+	const formattedRouteTextColor = formatHexColor(properties.route_text_color);
+	if (formattedRouteColor) formattedProperties.route_color = formattedRouteColor;
+	if (formattedRouteTextColor) formattedProperties.route_text_color = formattedRouteTextColor;
+	if (properties.routes && Array.isArray(properties.routes)) formattedProperties.routes = properties.routes.map((route) => formatProperties(route));
+	return formattedProperties;
+}
+/**
+* Converts GTFS shapes to GeoJSON Feature
+* @param {Shape[]} shapes - Array of GTFS shapes
+* @param {Record<string, unknown>} [properties={}] - Properties to add to the feature
+* @returns {Feature} GeoJSON Feature with MultiLineString geometry
+*/
+function shapesToGeoJSONFeature(shapes, properties = {}) {
+	return feature({
+		type: "MultiLineString",
+		coordinates: consolidateShapes(Object.values(groupBy(shapes, "shape_id")).map((shapeGroup) => sortBy(shapeGroup, "shape_pt_sequence")))
+	}, formatProperties(properties));
+}
+/**
+* Converts GTFS stops to GeoJSON FeatureCollection
+* @param {Stop[]} stops - Array of GTFS stops
+* @returns {FeatureCollection} GeoJSON FeatureCollection of Point features
+*/
+function stopsToGeoJSONFeatureCollection(stops) {
+	return featureCollection(compact(stops.map((stop) => {
+		if (!stop.stop_lon || !stop.stop_lat) return;
+		return feature({
+			type: "Point",
+			coordinates: [stop.stop_lon, stop.stop_lat]
+		}, formatProperties(omit(stop, ["stop_lat", "stop_lon"])));
+	})));
+}
+
+//#endregion
+//#region src/lib/utils.ts
+/**
+* Validates the configuration object for GTFS import
+* @param config The configuration object to validate
+* @throws Error if agencies are missing or if agency lacks both url and path
+* @returns The validated config object
+*/
+function validateConfigForImport(config) {
+	if (!config.agencies || config.agencies.length === 0) throw new GtfsError("No `agencies` specified in config", {
+		code: "GTFS_CONFIG_INVALID",
+		category: "config",
+		details: { field: "agencies" }
+	});
+	for (const [index, agency] of config.agencies.entries()) if (!agency.path && !agency.url) throw new GtfsError(`No Agency \`url\` or \`path\` specified in config for agency index ${index}.`, {
+		code: "GTFS_CONFIG_INVALID",
+		category: "config",
+		details: { agencyIndex: index }
+	});
+	return config;
+}
+/**
+* Initializes configuration with default values
+* @param initialConfig The user-provided configuration
+* @returns Merged configuration with defaults
+*/
+function setDefaultConfig(initialConfig) {
+	return {
+		sqlitePath: ":memory:",
+		ignoreDuplicates: false,
+		ignoreErrors: false,
+		gtfsRealtimeExpirationSeconds: 0,
+		verbose: true,
+		downloadTimeout: 3e4,
+		...initialConfig
+	};
+}
+/**
+* Converts a Long timestamp to ISO date string
+* @param longDate Object containing high, low, and unsigned values
+* @returns ISO formatted date string
+*/
+function convertLongTimeToDate(longDate) {
+	const { high, low, unsigned } = longDate;
+	return (/* @__PURE__ */ new Date(Long.fromBits(low, high, unsigned).toNumber() * 1e3)).toISOString();
+}
+/**
+* Converts time string in HH:mm:ss format to seconds since midnight
+* @param time Time string in HH:mm:ss format
+* @returns Number of seconds since midnight, or null if invalid format
+*/
+function calculateSecondsFromMidnight(time) {
+	if (!time || typeof time !== "string") return null;
+	const [hours, minutes, seconds] = time.split(":").map(Number);
+	if ([
+		hours,
+		minutes,
+		seconds
+	].some(isNaN) || minutes >= 60 || seconds >= 60) return null;
+	return hours * 3600 + minutes * 60 + seconds;
+}
+/**
+* Ensures time components have leading zeros (e.g., "9:5:1" -> "09:05:01")
+* @param time Time string in HH:mm:ss format
+* @returns Formatted time string with leading zeros, or null if invalid format
+*/
+function padLeadingZeros(time) {
+	const split = time.split(":").map((d) => String(Number(d)).padStart(2, "0"));
+	if (split.length !== 3) return null;
+	return split.join(":");
+}
+/**
+* Formats SQL SELECT clause from array of field names or field mapping object
+* @param fields Array of field names or object mapping source to alias
+* @returns Formatted SELECT clause
+*/
+function formatSelectClause(fields) {
+	if (Array.isArray(fields)) return `SELECT ${fields.length > 0 ? fields.map((fieldName) => sqlString.escapeId(fieldName)).join(", ") : "*"}`;
+	return `SELECT ${Object.entries(fields).map((key) => `${sqlString.escapeId(key[0])} AS ${sqlString.escapeId(key[1])}`).join(", ")}`;
+}
+/**
+* Formats SQL JOIN clause from array of join configurations
+* @param joinObject Array of join options
+* @returns Formatted JOIN clause
+*/
+function formatJoinClause(joinObject) {
+	return joinObject.map((data) => `${data.type ? data.type + " JOIN" : "INNER JOIN"} ${sqlString.escapeId(data.table)} ON ${data.on}`).join(" ");
+}
+/**
+* Converts degrees to radians
+* @param angle Angle in degrees
+* @returns Angle in radians
+*/
+function degree2radian(angle) {
+	return angle * Math.PI / 180;
+}
+/**
+* Converts radians to degrees
+* @param angle Angle in radians
+* @returns Angle in degrees
+*/
+function radian2degree(angle) {
+	return angle / Math.PI * 180;
+}
+const EARTH_RADIUS_METERS = 6371e3;
+/**
+* Creates SQL WHERE clause for geographic bounding box search
+* @param latitudeDegree Center latitude in degrees
+* @param longitudeDegree Center longitude in degrees
+* @param boundingBoxSideMeters Size of bounding box in meters
+* @returns SQL WHERE clause for bounding box search
+*/
+function formatWhereClauseBoundingBox(latitudeDegree, longitudeDegree, boundingBoxSideMeters) {
+	const lat = Number(latitudeDegree);
+	const lon = Number(longitudeDegree);
+	if (isNaN(lat) || isNaN(lon) || lat < -90 || lat > 90 || lon < -180 || lon > 180) throw new GtfsError("Invalid latitude or longitude values", {
+		code: "GTFS_QUERY_INVALID",
+		category: "query",
+		details: {
+			latitudeDegree,
+			longitudeDegree,
+			boundingBoxSideMeters
+		}
+	});
+	const latitudeRadian = degree2radian(lat);
+	const radiusFromLatitude = Math.cos(latitudeRadian) * EARTH_RADIUS_METERS;
+	const halfSide = boundingBoxSideMeters / 2;
+	const deltaLatitude = radian2degree(halfSide / EARTH_RADIUS_METERS);
+	const deltaLongitude = radian2degree(halfSide / radiusFromLatitude);
+	return [`stop_lat BETWEEN ${lat - deltaLatitude} AND ${lat + deltaLatitude}`, `stop_lon BETWEEN ${lon - deltaLongitude} AND ${lon + deltaLongitude}`].join(" AND ");
+}
+/**
+* Formats SQL WHERE clause for a single key-value pair
+* @param key Column name
+* @param value Single value, array of values, or null
+* @returns Formatted WHERE clause condition
+*/
+function formatWhereClause(key, value) {
+	if (Array.isArray(value)) {
+		let whereClause = `${sqlString.escapeId(key)} IN (${value.filter((v) => v !== null).map((v) => sqlString.escape(v)).join(", ")})`;
+		if (value.includes(null)) whereClause = `(${whereClause} OR ${sqlString.escapeId(key)} IS NULL)`;
+		return whereClause;
+	}
+	if (value === null) return `${sqlString.escapeId(key)} IS NULL`;
+	return `${sqlString.escapeId(key)} = ${sqlString.escape(value)}`;
+}
+/**
+* Formats complete SQL WHERE clause from query object
+* @param query Object containing column-value pairs
+* @returns Formatted WHERE clause or empty string if no conditions
+*/
+function formatWhereClauses(query) {
+	if (Object.keys(query).length === 0) return "";
+	return `WHERE ${Object.entries(query).map(([key, value]) => formatWhereClause(key, value)).join(" AND ")}`;
+}
+/**
+* Formats SQL ORDER BY clause from array of sorting criteria
+* @param orderBy Array of [column, direction] tuples
+* @returns Formatted ORDER BY clause
+*/
+function formatOrderByClause(orderBy) {
+	let orderByClause = "";
+	if (orderBy.length > 0) {
+		orderByClause += "ORDER BY ";
+		orderByClause += orderBy.map(([key, value]) => {
+			const direction = value === "DESC" ? "DESC" : "ASC";
+			return `${sqlString.escapeId(key)} ${direction}`;
+		}).join(", ");
+	}
+	return orderByClause;
+}
+/**
+* Gets day of week name from YYYYMMDD date number
+* @param date Date in YYYYMMDD format
+* @returns Lowercase day name (sunday-saturday)
+*/
+function getDayOfWeekFromDate(date) {
+	const DAYS_OF_WEEK = [
+		"sunday",
+		"monday",
+		"tuesday",
+		"wednesday",
+		"thursday",
+		"friday",
+		"saturday"
+	];
+	if (!Number.isInteger(date) || date.toString().length !== 8) throw new GtfsError("Date must be in YYYYMMDD format", {
+		code: "GTFS_INVALID_DATE",
+		category: "validation",
+		details: { value: date }
+	});
+	const year = Math.floor(date / 1e4);
+	const month = Math.floor(date % 1e4 / 100);
+	const day = date % 100;
+	const dateObj = new Date(year, month - 1, day);
+	if (dateObj.toString() === "Invalid Date") throw new GtfsError("Invalid date", {
+		code: "GTFS_INVALID_DATE",
+		category: "validation",
+		details: { value: date }
+	});
+	return DAYS_OF_WEEK[dateObj.getDay()];
+}
+/**
+* Formats a numeric value according to the decimal precision rules of the specified currency,
+* without any currency symbols or separators.
+* @param value The numeric value to format (e.g., 10.5)
+* @param currency The ISO 4217 currency code (e.g., 'USD', 'JPY', 'EUR')
+* @returns The formatted string with appropriate decimal places
+*          Examples:
+*          - formatCurrency(10.5, 'USD') => '10.50'    // USD uses 2 decimal places
+*          - formatCurrency(10.5, 'JPY') => '10'       // JPY uses 0 decimal places
+*          - formatCurrency(10.523, 'BHD') => '10.523' // BHD uses 3 decimal places
+*/
+function formatCurrency(value, currency) {
+	const parts = new Intl.NumberFormat(void 0, {
+		style: "currency",
+		currency
+	}).formatToParts(value);
+	const integerPart = parts.find((part) => part.type === "integer")?.value ?? "0";
+	const fractionPart = parts.find((part) => part.type === "fraction")?.value ?? "";
+	return `${integerPart}${fractionPart !== "" ? `.${fractionPart}` : ""}`;
+}
+/**
+* Gets the timestamp column name for a given column name
+* @param columnName The column name
+* @returns The timestamp column name
+*/
+function getTimestampColumnName(columnName) {
+	return columnName.endsWith("time") ? `${columnName}stamp` : `${columnName}_timestamp`;
+}
+/**
+* Applies a prefix to a value if the column should be prefixed and the value is not null
+* @param value The value to prefix
+* @param columnShouldBePrefixed Whether the column should be prefixed
+* @param prefix The prefix to apply
+* @returns The value with the prefix applied if the column should be prefixed and the value is not null
+*/
+function applyPrefixToValue(value, columnShouldBePrefixed, prefix) {
+	if (!columnShouldBePrefixed || prefix === void 0 || value === null || value === void 0) return value;
+	return `${prefix}${value}`;
+}
+/**
+* Pluralizes a word based on the count
+* @param singularWord The singular word
+* @param pluralWord The plural word
+* @param count The count of the word
+* @returns The pluralized word
+*/
+function pluralize(singularWord, pluralWord, count) {
+	return count === 1 ? singularWord : pluralWord;
+}
+
+//#endregion
+//#region src/lib/import-gtfs-realtime.ts
+const BATCH_SIZE$1 = 1e3;
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1e3;
+/**
+* Prepares a field value for database insertion
+*/
+function prepareRealtimeFieldValue(entity, column, task) {
+	if (column.name === "created_timestamp") return task.currentTimestamp;
+	if (column.name === "expiration_timestamp") return task.currentTimestamp + task.gtfsRealtimeExpirationSeconds;
+	const baseValue = column.source === void 0 ? column.default : get(entity, column.source, column.default);
+	const prefixedValue = applyPrefixToValue(baseValue?.__isLong__ ? convertLongTimeToDate(baseValue) : baseValue, column.prefix, task.prefix);
+	return column.type === "json" ? JSON.stringify(prefixedValue) : prefixedValue;
+}
+/**
+* Creates a prepared statement for a model
+*/
+function createPreparedStatement(db, model) {
+	const columns = model.schema.map((column) => column.name);
+	const placeholders = model.schema.map(() => "?").join(", ");
+	return db.prepare(`REPLACE INTO ${model.filenameBase} (${columns.join(", ")}) VALUES (${placeholders})`);
+}
+/**
+* Processes entities in batches
+*/
+async function processBatch(items, batchSize, processor) {
+	let totalRecordCount = 0;
+	let totalErrorCount = 0;
+	for (let i = 0; i < items.length; i += batchSize) {
+		const batch = items.slice(i, i + batchSize);
+		try {
+			const result = await processor(batch);
+			totalRecordCount += result.recordCount;
+			totalErrorCount += result.errorCount;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			totalErrorCount += batch.length;
+			console.error(`Batch processing error: ${errorMessage}`);
+		}
+	}
+	return {
+		recordCount: totalRecordCount,
+		errorCount: totalErrorCount
+	};
+}
+/**
+* Fetches GTFS Realtime data
+*/
+async function fetchGtfsRealtimeData(type, task) {
+	const urlConfig = getUrlConfig(type, task);
+	if (!urlConfig) return null;
+	task.log(`Importing - GTFS-Realtime from ${urlConfig.url}`);
+	for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) try {
+		const response = await fetch(urlConfig.url, {
+			method: "GET",
+			redirect: "follow",
+			headers: {
+				"User-Agent": "node-gtfs",
+				...urlConfig.headers ?? {},
+				"Accept-Encoding": "gzip"
+			},
+			signal: task.downloadTimeout ? AbortSignal.timeout(task.downloadTimeout) : void 0
+		});
+		if (!response.ok) throw new GtfsError(`HTTP ${response.status}: ${response.statusText}`, {
+			code: "GTFS_DOWNLOAD_HTTP",
+			category: "download",
+			statusCode: response.status,
+			details: {
+				url: urlConfig.url,
+				status: response.status,
+				statusText: response.statusText
+			}
+		});
+		const buffer = await response.arrayBuffer();
+		const message = GtfsRealtimeBindings.transit_realtime.FeedMessage.decode(new Uint8Array(buffer));
+		return GtfsRealtimeBindings.transit_realtime.FeedMessage.toObject(message, {
+			enums: String,
+			longs: String,
+			bytes: String,
+			defaults: false,
+			arrays: true,
+			objects: true,
+			oneofs: true
+		});
+	} catch (error) {
+		const gtfsError = toGtfsError(error, {
+			message: error instanceof Error ? error.message : String(error),
+			code: "GTFS_DOWNLOAD_FAILED",
+			category: "download",
+			details: {
+				type,
+				url: urlConfig.url
+			}
+		});
+		if (attempt === MAX_RETRIES) {
+			if (task.ignoreErrors) {
+				task.logError(`Failed to fetch ${type} after ${MAX_RETRIES} attempts: ${gtfsError.message}`);
+				if (task.report) addImportError(task.report, gtfsError);
+				return null;
+			}
+			throw gtfsError;
+		}
+		task.logWarning(`Attempt ${attempt} failed for ${type}: ${gtfsError.message}`);
+		await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY * attempt));
+	}
+	return null;
+}
+/**
+* Gets URL configuration for a specific realtime type
+*/
+function getUrlConfig(type, task) {
+	switch (type) {
+		case "alerts": return task.realtimeAlerts;
+		case "tripupdates": return task.realtimeTripUpdates;
+		case "vehiclepositions": return task.realtimeVehiclePositions;
+		default: return;
+	}
+}
+/**
+* Creates a processor for service alerts
+*/
+function createServiceAlertsProcessor(db, task) {
+	const alertStmt = createPreparedStatement(db, serviceAlerts);
+	const informedEntityStmt = createPreparedStatement(db, serviceAlertInformedEntities);
+	const deleteInformedEntitiesStmt = db.prepare(`DELETE FROM ${serviceAlertInformedEntities.filenameBase} WHERE alert_id = ?`);
+	return async (batch) => {
+		let recordCount = 0;
+		let errorCount = 0;
+		db.transaction(() => {
+			for (const entity of batch) try {
+				const alertId = applyPrefixToValue(entity.id, true, task.prefix);
+				deleteInformedEntitiesStmt.run(alertId);
+				const alertValues = serviceAlerts.schema.map((column) => prepareRealtimeFieldValue(entity, column, task));
+				alertStmt.run(alertValues);
+				recordCount++;
+				if (entity.alert?.informedEntity?.length) for (const informedEntity of entity.alert.informedEntity) {
+					informedEntity.parent = entity;
+					const entityValues = serviceAlertInformedEntities.schema.map((column) => prepareRealtimeFieldValue(informedEntity, column, task));
+					informedEntityStmt.run(entityValues);
+					recordCount++;
+				}
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				errorCount++;
+				task.logWarning(`Alert processing error: ${errorMessage}`);
+			}
+		})();
+		return {
+			recordCount,
+			errorCount
+		};
+	};
+}
+/**
+* Creates a processor for trip updates
+*/
+function createTripUpdatesProcessor(db, task) {
+	const tripUpdateStmt = createPreparedStatement(db, tripUpdates);
+	const stopTimeStmt = createPreparedStatement(db, stopTimeUpdates);
+	const deleteStopTimesByTripStmt = db.prepare(`DELETE FROM ${stopTimeUpdates.filenameBase} WHERE trip_id = ? AND trip_start_time IS ?`);
+	return async (batch) => {
+		let recordCount = 0;
+		let errorCount = 0;
+		db.transaction(() => {
+			for (const entity of batch) try {
+				const tripUpdateValues = tripUpdates.schema.map((column) => prepareRealtimeFieldValue(entity, column, task));
+				tripUpdateStmt.run(tripUpdateValues);
+				recordCount++;
+				if (entity.tripUpdate?.stopTimeUpdate?.length) {
+					const tripId = applyPrefixToValue(entity.tripUpdate?.trip?.tripId ?? null, true, task.prefix);
+					const tripStartTime = entity.tripUpdate?.trip?.startTime ?? null;
+					if (tripId !== null) deleteStopTimesByTripStmt.run(tripId, tripStartTime);
+					for (const stopTimeUpdate of entity.tripUpdate.stopTimeUpdate) {
+						stopTimeUpdate.parent = entity;
+						const stopTimeValues = stopTimeUpdates.schema.map((column) => prepareRealtimeFieldValue(stopTimeUpdate, column, task));
+						stopTimeStmt.run(stopTimeValues);
+						recordCount++;
+					}
+				}
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				errorCount++;
+				task.logWarning(`Trip update processing error: ${errorMessage}`);
+			}
+		})();
+		return {
+			recordCount,
+			errorCount
+		};
+	};
+}
+/**
+* Creates a processor for vehicle positions
+*/
+function createVehiclePositionsProcessor(db, task) {
+	const vehiclePositionStmt = createPreparedStatement(db, vehiclePositions);
+	return async (batch) => {
+		let recordCount = 0;
+		let errorCount = 0;
+		db.transaction(() => {
+			for (const entity of batch) try {
+				const fieldValues = vehiclePositions.schema.map((column) => prepareRealtimeFieldValue(entity, column, task));
+				vehiclePositionStmt.run(fieldValues);
+				recordCount++;
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				errorCount++;
+				task.logWarning(`Vehicle position processing error: ${errorMessage}`);
+			}
+		})();
+		return {
+			recordCount,
+			errorCount
+		};
+	};
+}
+/**
+* Removes expired GTFS-Realtime data
+*/
+function removeExpiredRealtimeData(config) {
+	const db = openDb(config);
+	log(config)(`Removing expired GTFS-Realtime data`);
+	db.transaction(() => {
+		for (const table of [
+			"vehicle_positions",
+			"trip_updates",
+			"stop_time_updates",
+			"service_alerts",
+			"service_alert_informed_entities"
+		]) db.prepare(`DELETE FROM ${table} WHERE expiration_timestamp <= strftime('%s','now')`).run();
+	})();
+	log(config)(`Removed expired GTFS-Realtime data\r`, true);
+}
+/**
+* Updates GTFS Realtime data
+*/
+async function updateGtfsRealtimeData(task) {
+	if (!task.realtimeAlerts && !task.realtimeTripUpdates && !task.realtimeVehiclePositions) return;
+	const [alertsData, tripUpdatesData, vehiclePositionsData] = await Promise.all([
+		task.realtimeAlerts?.url ? fetchGtfsRealtimeData("alerts", task) : null,
+		task.realtimeTripUpdates?.url ? fetchGtfsRealtimeData("tripupdates", task) : null,
+		task.realtimeVehiclePositions?.url ? fetchGtfsRealtimeData("vehiclepositions", task) : null
+	]);
+	const db = openDb({ sqlitePath: task.sqlitePath });
+	const recordCounts = {
+		alerts: 0,
+		tripupdates: 0,
+		vehiclepositions: 0
+	};
+	if (alertsData?.entity?.length) recordCounts.alerts = (await processBatch(alertsData.entity, BATCH_SIZE$1, createServiceAlertsProcessor(db, task))).recordCount;
+	if (tripUpdatesData?.entity?.length) recordCounts.tripupdates = (await processBatch(tripUpdatesData.entity, BATCH_SIZE$1, createTripUpdatesProcessor(db, task))).recordCount;
+	if (vehiclePositionsData?.entity?.length) recordCounts.vehiclepositions = (await processBatch(vehiclePositionsData.entity, BATCH_SIZE$1, createVehiclePositionsProcessor(db, task))).recordCount;
+	task.log(`GTFS-Realtime import complete: ${recordCounts.alerts} alerts, ${recordCounts.tripupdates} trip updates, ${recordCounts.vehiclepositions} vehicle positions`);
+}
+/**
+* Main function to update GTFS Realtime data
+*/
+async function updateGtfsRealtime(initialConfig) {
+	const config = setDefaultConfig(initialConfig);
+	validateConfigForImport(config);
+	try {
+		openDb(config);
+		const agencyCount = config.agencies.length;
+		log(config)(`Starting GTFS-Realtime refresh for ${pluralize("agency", "agencies", agencyCount)} using SQLite database at ${config.sqlitePath}`);
+		removeExpiredRealtimeData(config);
+		await mapSeries(config.agencies, async (agency) => {
+			let task;
+			try {
+				task = {
+					realtimeAlerts: agency.realtimeAlerts,
+					realtimeTripUpdates: agency.realtimeTripUpdates,
+					realtimeVehiclePositions: agency.realtimeVehiclePositions,
+					downloadTimeout: config.downloadTimeout,
+					gtfsRealtimeExpirationSeconds: config.gtfsRealtimeExpirationSeconds,
+					ignoreErrors: config.ignoreErrors,
+					sqlitePath: config.sqlitePath,
+					prefix: agency.prefix,
+					currentTimestamp: Math.floor(Date.now() / 1e3),
+					log: log(config),
+					logWarning: logWarning(config),
+					logError: logError(config)
+				};
+				await updateGtfsRealtimeData(task);
+			} catch (error) {
+				const gtfsError = toGtfsError(error, {
+					message: error instanceof Error ? error.message : String(error),
+					code: "GTFS_DB_OPERATION_FAILED",
+					category: "database",
+					details: { sqlitePath: task?.sqlitePath ?? config.sqlitePath }
+				});
+				if (config.ignoreErrors) {
+					logError(config)(formatGtfsError(gtfsError));
+					if (task?.report) addImportError(task.report, gtfsError);
+				} else throw gtfsError;
+			}
+		});
+		log(config)(`Completed GTFS-Realtime refresh for ${pluralize("agency", "agencies", agencyCount)}\n`);
+	} catch (error) {
+		if (error.code === "SQLITE_CANTOPEN") {
+			const dbOpenError = new GtfsError(`Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists or remove \`sqlitePath\` from config.json.`, {
+				code: "DB_OPEN_FAILED",
+				category: "database",
+				details: {
+					sqlitePath: config.sqlitePath,
+					dbCode: error.code
+				},
+				cause: error
+			});
+			logError(config)(dbOpenError.message);
+			throw dbOpenError;
+		}
+		throw toGtfsError(error, {
+			message: error instanceof Error ? error.message : String(error),
+			code: "GTFS_DB_OPERATION_FAILED",
+			category: "database"
+		});
+	}
+}
+
+//#endregion
+//#region src/lib/import-gtfs.ts
+function reportTaskError(task, error) {
+	if (task.report) addImportError(task.report, error);
+}
+const getTextFiles = async (folderPath) => {
+	return (await readdir(folderPath)).filter((filename) => filename.slice(-3) === "txt");
+};
+const downloadGtfsFiles = async (task) => {
+	if (!task.url) throw new GtfsError("No `url` specified in config", {
+		code: "GTFS_CONFIG_INVALID",
+		category: "config"
+	});
+	task.log(`Downloading GTFS from ${task.url}`);
+	task.path = `${task.downloadDir}/gtfs.zip`;
+	try {
+		const response = await fetch(task.url, {
+			method: "GET",
+			redirect: "follow",
+			headers: {
+				"User-Agent": "node-gtfs",
+				...task.headers
+			},
+			signal: task.downloadTimeout ? AbortSignal.timeout(task.downloadTimeout) : void 0
+		});
+		if (!response.ok) throw new GtfsError(`Unable to download GTFS from ${task.url}. Got status ${response.status}.`, {
+			code: "GTFS_DOWNLOAD_HTTP",
+			category: "download",
+			statusCode: response.status,
+			details: {
+				url: task.url,
+				status: response.status,
+				statusText: response.statusText
+			}
+		});
+		const buffer = await response.arrayBuffer();
+		await writeFile(task.path, Buffer.from(buffer));
+		task.log("Download successful");
+	} catch (error) {
+		throw toGtfsError(error, {
+			message: `Unable to download GTFS from ${task.url}.`,
+			code: "GTFS_DOWNLOAD_FAILED",
+			category: "download",
+			details: { url: task.url }
+		});
+	}
+};
+const extractGtfsFiles = async (task) => {
+	if (!task.path) throw new GtfsError("No `path` specified in config", {
+		code: "GTFS_CONFIG_INVALID",
+		category: "config",
+		details: { field: "path" }
+	});
+	const gtfsPath = untildify(task.path);
+	task.log(`Importing static GTFS from ${task.path}\r`);
+	if (path.extname(gtfsPath) === ".zip") try {
+		await unzip(gtfsPath, task.downloadDir);
+		if ((await getTextFiles(task.downloadDir)).length === 0) {
+			const folders = (await readdir(task.downloadDir)).filter((filename) => !["__MACOSX"].includes(filename)).map((filename) => path.join(task.downloadDir, filename)).filter((source) => lstatSync(source).isDirectory());
+			if (folders.length > 1) throw new GtfsError(`More than one subfolder found in zip file at \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`, {
+				code: "GTFS_ZIP_INVALID",
+				category: "zip",
+				details: {
+					path: task.path,
+					folderCount: folders.length
+				}
+			});
+			else if (folders.length === 0) throw new GtfsError(`No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`, {
+				code: "GTFS_ZIP_INVALID",
+				category: "zip",
+				details: { path: task.path }
+			});
+			const subfolderName = folders[0];
+			const directoryTextFiles = await getTextFiles(subfolderName);
+			if (directoryTextFiles.length === 0) throw new GtfsError(`No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`, {
+				code: "GTFS_ZIP_INVALID",
+				category: "zip",
+				details: {
+					path: task.path,
+					subfolderName
+				}
+			});
+			await Promise.all(directoryTextFiles.map(async (fileName) => rename(path.join(subfolderName, fileName), path.join(task.downloadDir, fileName))));
+		}
+	} catch (error) {
+		const wrappedError = toGtfsError(error, {
+			message: `Unable to unzip file ${task.path}`,
+			code: "GTFS_ZIP_INVALID",
+			category: "zip",
+			details: { path: task.path }
+		});
+		task.logError(formatGtfsError(wrappedError));
+		throw wrappedError;
+	}
+	else try {
+		await cp(gtfsPath, task.downloadDir, { recursive: true });
+	} catch (error) {
+		throw new GtfsError(`Unable to load files from path \`${gtfsPath}\` defined in configuration. Verify that path exists and contains GTFS files.`, {
+			code: "GTFS_DOWNLOAD_FAILED",
+			category: "download",
+			details: { path: gtfsPath },
+			cause: error
+		});
+	}
+};
+const createGtfsTables = (db) => {
+	for (const model of Object.values(models_exports)) {
+		if (!model.schema) continue;
+		const sqlColumnCreateStatements = [];
+		for (const column of model.schema) {
+			const checks = [];
+			if (column.min !== void 0 && column.max !== void 0) checks.push(`${column.name} >= ${column.min} AND ${column.name} <= ${column.max}`);
+			else if (column.min !== void 0) checks.push(`${column.name} >= ${column.min}`);
+			else if (column.max !== void 0) checks.push(`${column.name} <= ${column.max}`);
+			if (column.type === "integer") checks.push(`(TYPEOF(${column.name}) = 'integer' OR ${column.name} IS NULL)`);
+			else if (column.type === "real") checks.push(`(TYPEOF(${column.name}) = 'real' OR ${column.name} IS NULL)`);
+			const required = column.required ? "NOT NULL" : "";
+			const columnDefault = column.default ? "DEFAULT " + column.default : "";
+			const columnCollation = column.nocase ? "COLLATE NOCASE" : "";
+			const checkClause = checks.length > 0 ? `CHECK(${checks.join(" AND ")})` : "";
+			sqlColumnCreateStatements.push(`${column.name} ${column.type} ${checkClause} ${required} ${columnDefault} ${columnCollation}`);
+			if (column.type === "time") sqlColumnCreateStatements.push(`${getTimestampColumnName(column.name)} INTEGER GENERATED ALWAYS AS (
+            CASE
+              WHEN ${column.name} IS NULL OR ${column.name} = '' THEN NULL
+              ELSE CAST(
+                substr(${column.name}, 1, instr(${column.name}, ':') - 1) * 3600 +
+                substr(${column.name}, instr(${column.name}, ':') + 1, 2) * 60 +
+                substr(${column.name}, -2) AS INTEGER
+              )
+            END
+          ) STORED`);
+		}
+		const primaryColumns = model.schema.filter((column) => column.primary);
+		if (primaryColumns.length > 0) sqlColumnCreateStatements.push(`PRIMARY KEY (${primaryColumns.map(({ name }) => name).join(", ")})`);
+		db.prepare(`DROP TABLE IF EXISTS ${model.filenameBase};`).run();
+		db.prepare(`CREATE TABLE ${model.filenameBase} (${sqlColumnCreateStatements.join(", ")});`).run();
+	}
+};
+const createGtfsIndexes = (db) => {
+	for (const model of Object.values(models_exports)) {
+		if (!model.schema) continue;
+		for (const column of model.schema) {
+			if (column.index) db.prepare(`CREATE INDEX idx_${model.filenameBase}_${column.name} ON ${model.filenameBase} (${column.name});`).run();
+			if (column.type === "time") {
+				const timestampColumnName = getTimestampColumnName(column.name);
+				db.prepare(`CREATE INDEX idx_${model.filenameBase}_${timestampColumnName} ON ${model.filenameBase} (${timestampColumnName});`).run();
+			}
+		}
+	}
+};
+const formatGtfsLine = (line, model, totalLineCount) => {
+	const lineNumber = totalLineCount + 1;
+	const formattedLine = {};
+	const filenameBase = model.filenameBase;
+	const filenameExtension = model.filenameExtension;
+	for (const { name, type, required } of model.schema) {
+		let value = line[name];
+		if (value === "" || value === void 0 || value === null) {
+			formattedLine[name] = null;
+			if (required) throw new GtfsError(`Missing required value in ${filenameBase}.${filenameExtension} for ${name} on line ${lineNumber}.`, {
+				code: "GTFS_REQUIRED_FIELD_MISSING",
+				category: "validation",
+				details: {
+					file: `${filenameBase}.${filenameExtension}`,
+					line: lineNumber,
+					column: name
+				}
+			});
+			continue;
+		}
+		if (type === "date") {
+			value = value?.toString().replace(/-/g, "");
+			if (value.length !== 8) throw new GtfsError(`Invalid date in ${filenameBase}.${filenameExtension} for ${name} on line ${lineNumber}.`, {
+				code: "GTFS_INVALID_DATE",
+				category: "validation",
+				details: {
+					file: `${filenameBase}.${filenameExtension}`,
+					line: lineNumber,
+					column: name,
+					value
+				}
+			});
+		} else if (type === "time") value = padLeadingZeros(value);
+		if (type === "json") value = JSON.stringify(value);
+		formattedLine[name] = value;
+	}
+	return formattedLine;
+};
+const BATCH_SIZE = 1e5;
+const importGtfsFiles = async (db, task) => {
+	await mapSeries(Object.values(models_exports), (model) => new Promise((resolve, reject) => {
+		let totalLineCount = 0;
+		const filename = `${model.filenameBase}.${model.filenameExtension}`;
+		if (task.exclude && task.exclude.includes(model.filenameBase)) {
+			task.log(`Skipping - ${filename}\r`);
+			resolve();
+			return;
+		}
+		if (model.extension === "gtfs-realtime") {
+			resolve();
+			return;
+		}
+		const filepath = path.join(task.downloadDir, `${filename}`);
+		if (!existsSync(filepath)) {
+			if (!model.nonstandard) task.log(`Importing - ${filename} - No file found\r`);
+			resolve();
+			return;
+		}
+		task.log(`Importing - ${filename}\r`);
+		const columns = model.schema;
+		const prefixedColumns = new Set(columns.filter((column) => column.prefix).map((column) => column.name));
+		const prepareStatement = `INSERT ${task.ignoreDuplicates ? "OR IGNORE" : ""} INTO ${model.filenameBase} (${columns.map(({ name }) => name).join(", ")}) VALUES (${columns.map(({ name }) => `@${name}`).join(", ")})`;
+		const insert = db.prepare(prepareStatement);
+		const insertLines = db.transaction((lines) => {
+			for (const [rowNumber, line] of Object.entries(lines)) try {
+				if (task.prefix === void 0) insert.run(line);
+				else {
+					const prefixedLine = Object.fromEntries(Object.entries(line).map(([columnName, value]) => [columnName, applyPrefixToValue(value, prefixedColumns.has(columnName), task.prefix)]));
+					insert.run(prefixedLine);
+				}
+			} catch (error) {
+				if (error.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+					const primaryColumns = columns.filter((column) => column.primary);
+					task.logWarning(`Duplicate values for primary key (${primaryColumns.map((column) => column.name).join(", ")}) found in ${filename}. Set the \`ignoreDuplicates\` option to true in config.json to ignore this error`);
+					if (task.report) addImportWarning(task.report, {
+						code: "GTFS_DUPLICATE_PRIMARY_KEY",
+						message: `Duplicate values for primary key found in ${filename}.`,
+						details: {
+							file: filename,
+							line: Number(rowNumber) + 1,
+							columns: primaryColumns.map((column) => column.name)
+						}
+					});
+				}
+				task.logWarning(`Check ${filename} for invalid data on line ${rowNumber + 1}.`);
+				throw toGtfsError(error, {
+					message: error instanceof Error ? error.message : String(error),
+					code: "GTFS_DB_OPERATION_FAILED",
+					category: "database",
+					details: {
+						file: filename,
+						line: Number(rowNumber) + 1,
+						sqlitePath: task.sqlitePath,
+						dbCode: error.code
+					}
+				});
+			}
+		});
+		if (model.filenameExtension === "txt") {
+			const parser = parse({
+				columns: true,
+				relax_quotes: true,
+				trim: true,
+				skip_empty_lines: true,
+				...task.csvOptions
+			});
+			let lines = [];
+			parser.on("readable", () => {
+				try {
+					let record;
+					while (record = parser.read()) {
+						totalLineCount += 1;
+						lines.push(formatGtfsLine(record, model, totalLineCount));
+						if (lines.length >= BATCH_SIZE) {
+							insertLines(lines);
+							lines = [];
+							task.log(`Importing - ${filename} - ${totalLineCount} lines imported\r`, true);
+						}
+					}
+				} catch (error) {
+					const gtfsError = toGtfsError(error, {
+						message: error instanceof Error ? error.message : String(error),
+						code: "GTFS_CSV_PARSE_FAILED",
+						category: "parse",
+						details: { file: filename }
+					});
+					if (task.ignoreErrors) {
+						reportTaskError(task, gtfsError);
+						task.logError(`Error processing ${filename}: ${gtfsError.message}`);
+						resolve();
+					} else reject(gtfsError);
+				}
+			});
+			parser.on("end", () => {
+				try {
+					if (lines.length > 0) try {
+						insertLines(lines);
+					} catch (error) {
+						const gtfsError = toGtfsError(error, {
+							message: error instanceof Error ? error.message : String(error),
+							code: "GTFS_DB_OPERATION_FAILED",
+							category: "database",
+							details: {
+								file: filename,
+								sqlitePath: task.sqlitePath
+							}
+						});
+						if (task.ignoreErrors) {
+							task.logError(`Error inserting data for ${filename}: ${gtfsError.message}`);
+							reportTaskError(task, gtfsError);
+							resolve();
+							return;
+						} else {
+							reject(gtfsError);
+							return;
+						}
+					}
+					task.log(`Importing - ${filename} - ${totalLineCount} lines imported\r`, true);
+					resolve();
+				} catch (error) {
+					const gtfsError = toGtfsError(error, {
+						message: error instanceof Error ? error.message : String(error),
+						code: "GTFS_DB_OPERATION_FAILED",
+						category: "database",
+						details: {
+							file: filename,
+							sqlitePath: task.sqlitePath
+						}
+					});
+					if (task.ignoreErrors) {
+						task.logError(`Error finalizing ${filename}: ${gtfsError.message}`);
+						reportTaskError(task, gtfsError);
+						resolve();
+					} else reject(gtfsError);
+				}
+			});
+			parser.on("error", (error) => {
+				const gtfsError = toGtfsError(error, {
+					message: error instanceof Error ? error.message : String(error),
+					code: "GTFS_CSV_PARSE_FAILED",
+					category: "parse",
+					details: { file: filename }
+				});
+				if (task.ignoreErrors) {
+					task.logError(`Parser error for ${filename}: ${gtfsError.message}`);
+					reportTaskError(task, gtfsError);
+					resolve();
+				} else reject(gtfsError);
+			});
+			createReadStream(filepath).pipe(stripBomStream()).pipe(parser);
+		} else if (model.filenameExtension === "geojson") readFile(filepath, "utf8").then((data) => {
+			if (isValidJSON(data) === false) if (task.ignoreErrors) {
+				task.logError(`Invalid JSON in ${filename}`);
+				reportTaskError(task, new GtfsError(`Invalid JSON in ${filename}`, {
+					code: "GTFS_JSON_INVALID",
+					category: "parse",
+					details: { file: filename }
+				}));
+				resolve();
+				return;
+			} else {
+				reject(new GtfsError(`Invalid JSON in ${filename}`, {
+					code: "GTFS_JSON_INVALID",
+					category: "parse",
+					details: { file: filename }
+				}));
+				return;
+			}
+			totalLineCount += 1;
+			const line = formatGtfsLine({ geojson: data }, model, totalLineCount);
+			try {
+				insertLines([line]);
+				task.log(`Importing - ${filename} - ${totalLineCount} lines imported\r`, true);
+				resolve();
+			} catch (error) {
+				const gtfsError = toGtfsError(error, {
+					message: error instanceof Error ? error.message : String(error),
+					code: "GTFS_DB_OPERATION_FAILED",
+					category: "database",
+					details: {
+						file: filename,
+						sqlitePath: task.sqlitePath
+					}
+				});
+				if (task.ignoreErrors) {
+					task.logError(`Error inserting data for ${filename}: ${gtfsError.message}`);
+					reportTaskError(task, gtfsError);
+					resolve();
+				} else reject(gtfsError);
+			}
+		}).catch((error) => {
+			const gtfsError = toGtfsError(error, {
+				message: error instanceof Error ? error.message : String(error),
+				code: "GTFS_CSV_PARSE_FAILED",
+				category: "parse",
+				details: { file: filename }
+			});
+			if (task.ignoreErrors) {
+				task.logError(`Error reading ${filename}: ${gtfsError.message}`);
+				reportTaskError(task, gtfsError);
+				resolve();
+			} else reject(gtfsError);
+		});
+		else if (task.ignoreErrors) {
+			task.logError(`Unsupported file type: ${model.filenameExtension} for ${filename}`);
+			resolve();
+		} else reject(new GtfsError(`Unsupported file type: ${model.filenameExtension}`, {
+			code: "GTFS_UNSUPPORTED_FILE_TYPE",
+			category: "parse",
+			details: {
+				file: filename,
+				extension: model.filenameExtension
+			}
+		}));
+	}));
+	task.log(`Static GTFS import complete`);
+};
+async function importGtfs(initialConfig) {
+	const startTime = process.hrtime.bigint();
+	const config = setDefaultConfig(initialConfig);
+	validateConfigForImport(config);
+	const report = config.includeImportReport ? createImportReport() : void 0;
+	try {
+		const db = openDb(config);
+		const agencyCount = config.agencies.length;
+		log(config)(`Starting GTFS import for ${pluralize("file", "files", agencyCount)} using SQLite database at ${config.sqlitePath}`);
+		createGtfsTables(db);
+		await mapSeries(config.agencies, async (agency) => {
+			try {
+				const tempPath = temporaryDirectory();
+				const task = {
+					exclude: agency.exclude,
+					headers: agency.headers,
+					realtimeAlerts: agency.realtimeAlerts,
+					realtimeTripUpdates: agency.realtimeTripUpdates,
+					realtimeVehiclePositions: agency.realtimeVehiclePositions,
+					downloadDir: tempPath,
+					downloadTimeout: config.downloadTimeout,
+					gtfsRealtimeExpirationSeconds: config.gtfsRealtimeExpirationSeconds,
+					csvOptions: config.csvOptions || {},
+					ignoreDuplicates: config.ignoreDuplicates,
+					ignoreErrors: config.ignoreErrors,
+					sqlitePath: config.sqlitePath,
+					prefix: agency.prefix,
+					currentTimestamp: Math.floor(Date.now() / 1e3),
+					log: log(config),
+					logWarning: logWarning(config),
+					logError: logError(config),
+					report
+				};
+				if ("url" in agency) {
+					Object.assign(task, { url: agency.url });
+					await downloadGtfsFiles(task);
+				} else Object.assign(task, { path: agency.path });
+				await extractGtfsFiles(task);
+				await importGtfsFiles(db, task);
+				await updateGtfsRealtimeData(task);
+				await rm(tempPath, { recursive: true });
+			} catch (error) {
+				const wrappedError = toGtfsError(error, {
+					message: error instanceof Error ? error.message : String(error),
+					code: "GTFS_CSV_PARSE_FAILED",
+					category: "parse"
+				});
+				if (config.ignoreErrors) {
+					logError(config)(formatGtfsError(wrappedError));
+					if (report) addImportError(report, wrappedError);
+				} else throw wrappedError;
+			}
+		});
+		log(config)(`Creating DB indexes`);
+		createGtfsIndexes(db);
+		const endTime = process.hrtime.bigint();
+		const elapsedSeconds = Number(endTime - startTime) / 1e9;
+		log(config)(`Completed GTFS import in ${elapsedSeconds.toFixed(1)} seconds\n`);
+	} catch (error) {
+		if (error.code === "SQLITE_CANTOPEN") {
+			const dbOpenError = new GtfsError(`Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists or remove \`sqlitePath\` from config.json.`, {
+				code: "DB_OPEN_FAILED",
+				category: "database",
+				details: {
+					sqlitePath: config.sqlitePath,
+					dbCode: error.code
+				},
+				cause: error
+			});
+			logError(config)(dbOpenError.message);
+			throw dbOpenError;
+		}
+		throw toGtfsError(error, {
+			message: error instanceof Error ? error.message : String(error),
+			code: "GTFS_CSV_PARSE_FAILED",
+			category: "parse"
+		});
+	}
+	if (report) return report;
+}
+
+//#endregion
+//#region src/lib/export.ts
+const getAgencies$1 = (db, config) => {
+	try {
+		return db.prepare("SELECT agency_name FROM agency;").all();
+	} catch {
+		if (config.sqlitePath === ":memory:") throw new Error("No agencies found in SQLite. You are using an in-memory database - if running this from command line be sure to specify a value for `sqlitePath` in config.json other than \":memory:\".");
+		throw new Error("No agencies found in SQLite. Be sure to first import data into SQLite using `gtfs-import` or `importGtfs(config);`");
+	}
+};
+const exportGtfs = async (initialConfig) => {
+	const config = setDefaultConfig(initialConfig);
+	const db = openDb(config);
+	const agencies = getAgencies$1(db, config);
+	const agencyCount = agencies.length;
+	if (agencyCount === 0) throw new Error("No agencies found in SQLite. Be sure to first import data into SQLite using `gtfs-import` or `importGtfs(config);`");
+	else if (agencyCount > 1) logWarning(config)("More than one agency is defined in config.json. Export will merge all into one GTFS file.");
+	log(config)(`Starting GTFS export for ${pluralize("agency", "agencies", agencyCount)} using SQLite database at ${config.sqlitePath}`);
+	const folderName = generateFolderName(agencies[0].agency_name);
+	const defaultExportPath = path.join(process.cwd(), "gtfs-export", folderName);
+	const exportPath = untildify(config.exportPath || defaultExportPath);
+	await prepDirectory(exportPath);
+	if (compact(await mapSeries(Object.values(models_exports).filter((model) => model.extension !== "gtfs-realtime"), async (model) => {
+		const filePath = path.join(exportPath, `${model.filenameBase}.${model.filenameExtension}`);
+		const tableName = sqlString.escapeId(model.filenameBase);
+		const lines = db.prepare(`SELECT * FROM ${tableName};`).all();
+		if (!lines || lines.length === 0) {
+			if (!model.nonstandard) log(config)(`Skipping (no data) - ${model.filenameBase}.${model.filenameExtension}\r`);
+			return;
+		}
+		if (model.filenameExtension === "txt") {
+			const excludeColumns = [];
+			if (model.filenameBase === "routes") {
+				const routesWithAgencyId = db.prepare("SELECT agency_id FROM routes WHERE agency_id IS NOT NULL;").all();
+				if (!routesWithAgencyId || routesWithAgencyId.length === 0) excludeColumns.push("agency_id");
+			} else if (model.filenameBase === "fare_attributes") for (const line of lines) line.price = formatCurrency(line.price, line.currency_type);
+			else if (model.filenameBase === "fare_products") for (const line of lines) line.amount = formatCurrency(line.amount, line.currency);
+			await writeFile(filePath, await stringify(lines, {
+				columns: without(model.schema.map((column) => column.name), ...excludeColumns),
+				header: true
+			}));
+		} else if (model.filenameExtension === "geojson") await writeFile(filePath, lines?.[0].geojson ?? "");
+		else throw new Error(`Unexpected filename extension: ${model.filenameExtension}`);
+		log(config)(`Exporting - ${model.filenameBase}.${model.filenameExtension}\r`);
+		return `${model.filenameBase}.${model.filenameExtension}`;
+	})).length === 0) {
+		log(config)("No GTFS data exported. Be sure to first import data into SQLite.");
+		return;
+	}
+	log(config)(`Completed GTFS export to ${exportPath}`);
+	log(config)(`Completed GTFS export for ${pluralize("agency", "agencies", agencyCount)}\n`);
+};
+
+//#endregion
+//#region src/lib/advancedQuery.ts
+function advancedQuery(table, advancedQueryOptions) {
+	const queryOptions = {
+		query: {},
+		fields: [],
+		orderBy: [],
+		join: [],
+		options: {},
+		...advancedQueryOptions
+	};
+	const db = queryOptions.options.db ?? openDb();
+	const tableName = sqlString.escapeId(table);
+	const selectClause = formatSelectClause(queryOptions.fields);
+	const whereClause = formatWhereClauses(queryOptions.query);
+	const joinClause = formatJoinClause(queryOptions.join);
+	const orderByClause = formatOrderByClause(queryOptions.orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${joinClause} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/agencies.ts
+function getAgencies(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "agency";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/areas.ts
+function getAreas(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "areas";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/attributions.ts
+function getAttributions(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "attributions";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/booking-rules.ts
+function getBookingRules(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "booking_rules";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/calendar-dates.ts
+function getCalendarDates(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "calendar_dates";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/calendars.ts
+function getCalendars(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "calendar";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+function getServiceIdsByDate(date, options = {}) {
+	const db = options.db ?? openDb();
+	if (!date) throw new GtfsError("`date` is a required query parameter", {
+		code: "GTFS_QUERY_INVALID",
+		category: "query",
+		details: { field: "date" }
+	});
+	const dayOfWeek = getDayOfWeekFromDate(date);
+	return db.prepare(`
+    SELECT service_id FROM (
+      SELECT service_id
+      FROM calendar
+      WHERE start_date <= ? AND end_date >= ? AND ${dayOfWeek} = 1
+      UNION
+      SELECT service_id
+      FROM calendar_dates
+      WHERE date = ? AND exception_type = 1
+    )
+    EXCEPT
+    SELECT service_id
+    FROM calendar_dates
+    WHERE date = ? AND exception_type = 2
+  `).all(date, date, date, date).map((record) => record.service_id);
+}
+
+//#endregion
+//#region src/lib/gtfs/fare-attributes.ts
+function getFareAttributes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "fare_attributes";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/fare-leg-rules.ts
+function getFareLegRules(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "fare_leg_rules";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/fare-media.ts
+function getFareMedia(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "fare_media";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/fare-products.ts
+function getFareProducts(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "fare_products";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/fare-rules.ts
+function getFareRules(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "fare_rules";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/fare-transfer-rules.ts
+function getFareTransferRules(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "fare_transfer_rules";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/feed-info.ts
+function getFeedInfo(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "feed_info";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/frequencies.ts
+function getFrequencies(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "frequencies";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/levels.ts
+function getLevels(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "levels";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/location-groups.ts
+function getLocationGroups(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "location_groups";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/location-group-stops.ts
+function getLocationGroupStops(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "location_group_stops";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/locations.ts
+function getLocations(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "locations";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/networks.ts
+function getNetworks(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "networks";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/pathways.ts
+function getPathways(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "pathways";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/rider-categories.ts
+function getRiderCategories(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "rider_categories";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/route-networks.ts
+function getRouteNetworks(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "route_networks";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/routes.ts
+function buildStoptimeSubquery$1(query) {
+	return `SELECT DISTINCT trip_id FROM stop_times ${formatWhereClauses(query)}`;
+}
+function buildTripSubquery$2(query) {
+	let whereClause = "";
+	const tripQuery = omit(query, ["stop_id"]);
+	const stoptimeQuery = pick(query, ["stop_id"]);
+	const whereClauses = Object.entries(tripQuery).map(([key, value]) => formatWhereClause(key, value));
+	if (Object.values(stoptimeQuery).length > 0) whereClauses.push(`trip_id IN (${buildStoptimeSubquery$1(stoptimeQuery)})`);
+	if (whereClauses.length > 0) whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+	return `SELECT DISTINCT route_id FROM trips ${whereClause}`;
+}
+function getRoutes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "routes";
+	const selectClause = formatSelectClause(fields);
+	let whereClause = "";
+	const orderByClause = formatOrderByClause(orderBy);
+	const routeQuery = omit(query, ["stop_id", "service_id"]);
+	const tripQuery = pick(query, ["stop_id", "service_id"]);
+	const whereClauses = Object.entries(routeQuery).map(([key, value]) => formatWhereClause(key, value));
+	if (Object.values(tripQuery).length > 0) whereClauses.push(`route_id IN (${buildTripSubquery$2(tripQuery)})`);
+	if (whereClauses.length > 0) whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-plus/route-attributes.ts
+function getRouteAttributes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "route_attributes";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/shapes.ts
+function buildTripSubquery$1(query) {
+	return `SELECT DISTINCT shape_id FROM trips ${formatWhereClauses(query)}`;
+}
+function getShapes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "shapes";
+	const selectClause = formatSelectClause(fields);
+	let whereClause = "";
+	const orderByClause = formatOrderByClause(orderBy);
+	const shapeQuery = omit(query, [
+		"route_id",
+		"trip_id",
+		"service_id",
+		"direction_id"
+	]);
+	const tripQuery = pick(query, [
+		"route_id",
+		"trip_id",
+		"service_id",
+		"direction_id"
+	]);
+	const whereClauses = Object.entries(shapeQuery).map(([key, value]) => formatWhereClause(key, value));
+	if (Object.values(tripQuery).length > 0) whereClauses.push(`shape_id IN (${buildTripSubquery$1(tripQuery)})`);
+	if (whereClauses.length > 0) whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+function getShapesAsGeoJSON(query = {}, options = {}) {
+	const agencies = getAgencies({}, [], [], options);
+	return featureCollection(compact(getRoutes(pick(query, ["route_id"]), [], [], options).map((route) => {
+		const shapes = getShapes({
+			route_id: route.route_id,
+			...omit(query, "route_id")
+		}, [], [], options);
+		if (shapes.length === 0) return;
+		const routeAttributes = getRouteAttributes({ route_id: route.route_id }, [], [], options);
+		const agency = agencies.find((agency) => agency.agency_id === route.agency_id);
+		return shapesToGeoJSONFeature(shapes, {
+			agency_name: agency ? agency.agency_name : void 0,
+			shape_id: query.shape_id,
+			...route,
+			...routeAttributes?.[0] || []
+		});
+	})));
+}
+
+//#endregion
+//#region src/lib/gtfs/stop-areas.ts
+function getStopAreas(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "stop_areas";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-plus/stop-attributes.ts
+function getStopAttributes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "stop_attributes";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/stops.ts
+function buildTripSubquery(query) {
+	return `SELECT trip_id FROM trips ${formatWhereClauses(query)}`;
+}
+function buildStoptimeSubquery(query) {
+	return `SELECT DISTINCT stop_id FROM stop_times WHERE trip_id IN (${buildTripSubquery(query)})`;
+}
+function getStops(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "stops";
+	const selectClause = formatSelectClause(fields);
+	let whereClause = "";
+	let orderByClause = formatOrderByClause(orderBy);
+	const stopQueryOmitKeys = [
+		"route_id",
+		"trip_id",
+		"service_id",
+		"direction_id",
+		"shape_id"
+	];
+	if (options.bounding_box_side_m !== void 0) stopQueryOmitKeys.push("stop_lat", "stop_lon");
+	const stopQuery = omit(query, stopQueryOmitKeys);
+	const tripQuery = pick(query, [
+		"route_id",
+		"trip_id",
+		"service_id",
+		"direction_id",
+		"shape_id"
+	]);
+	const whereClauses = Object.entries(stopQuery).map(([key, value]) => formatWhereClause(key, value));
+	if (options.bounding_box_side_m !== void 0 && query.stop_lat !== void 0 && query.stop_lon !== void 0) {
+		whereClauses.push(formatWhereClauseBoundingBox(query.stop_lat, query.stop_lon, options.bounding_box_side_m));
+		if (orderBy.length === 0) orderByClause = `ORDER BY (((stop_lat - ${query.stop_lat}) * (stop_lat - ${query.stop_lat})) + ((stop_lon - ${query.stop_lon}) * (stop_lon - ${query.stop_lon}))) ASC`;
+	}
+	if (Object.values(tripQuery).length > 0) whereClauses.push(`stop_id IN (${buildStoptimeSubquery(tripQuery)})`);
+	if (whereClauses.length > 0) whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+function getStopsAsGeoJSON(query = {}, options = {}) {
+	const db = options.db ?? openDb();
+	const stops = getStops(query, [], [], options);
+	const agencies = getAgencies({}, [], [], options);
+	return stopsToGeoJSONFeatureCollection(stops.map((stop) => {
+		const routes = db.prepare(`SELECT * FROM routes WHERE route_id IN (SELECT DISTINCT route_id FROM trips WHERE trip_id IN (SELECT DISTINCT trip_id FROM stop_times WHERE stop_id = ?))`).all(stop.stop_id);
+		const stopAttributes = getStopAttributes({ stop_id: stop.stop_id });
+		return {
+			...stop,
+			...stopAttributes?.[0] || [],
+			routes: orderBy(routes, (route) => route?.route_short_name ? Number.parseInt(route.route_short_name, 10) : 0),
+			agency_name: agencies[0]?.agency_name ?? null
+		};
+	}).filter((stop) => stop.routes.length > 0));
+}
+
+//#endregion
+//#region src/lib/gtfs/stop-times.ts
+function getStoptimes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "stop_times";
+	const selectClause = formatSelectClause(fields);
+	let whereClause = "";
+	const orderByClause = formatOrderByClause(orderBy);
+	const stoptimeQuery = omit(query, [
+		"date",
+		"start_time",
+		"end_time"
+	]);
+	const whereClauses = Object.entries(stoptimeQuery).map(([key, value]) => formatWhereClause(key, value));
+	if (query.date) {
+		if (typeof query.date !== "number") throw new GtfsError("`date` must be a number in yyyymmdd format", {
+			code: "GTFS_QUERY_INVALID",
+			category: "query",
+			details: {
+				field: "date",
+				value: query.date
+			}
+		});
+		const tripSubquery = `SELECT DISTINCT trip_id FROM trips WHERE service_id IN (${getServiceIdsByDate(query.date, options).map((id) => sqlString.escape(id)).join(",")})`;
+		whereClauses.push(`trip_id IN (${tripSubquery})`);
+	}
+	if (query.start_time) {
+		if (typeof query.start_time !== "string") throw new GtfsError("`start_time` must be a string in HH:mm:ss format", {
+			code: "GTFS_QUERY_INVALID",
+			category: "query",
+			details: {
+				field: "start_time",
+				value: query.start_time
+			}
+		});
+		whereClauses.push(`arrival_timestamp >= ${calculateSecondsFromMidnight(query.start_time)}`);
+	}
+	if (query.end_time) {
+		if (typeof query.end_time !== "string") throw new GtfsError("`end_time` must be a string in HH:mm:ss format", {
+			code: "GTFS_QUERY_INVALID",
+			category: "query",
+			details: {
+				field: "end_time",
+				value: query.end_time
+			}
+		});
+		whereClauses.push(`departure_timestamp <= ${calculateSecondsFromMidnight(query.end_time)}`);
+	}
+	if (whereClauses.length > 0) whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/timeframes.ts
+function getTimeframes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "timeframes";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/transfers.ts
+function getTransfers(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "transfers";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/translations.ts
+function getTranslations(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "translations";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs/trips.ts
+function getTrips(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "trips";
+	const selectClause = formatSelectClause(fields);
+	let whereClause = "";
+	const orderByClause = formatOrderByClause(orderBy);
+	const tripQuery = omit(query, ["date"]);
+	const whereClauses = Object.entries(tripQuery).map(([key, value]) => formatWhereClause(key, value));
+	if (query.date) {
+		if (typeof query.date !== "number") throw new GtfsError("`date` must be a number in yyyymmdd format", {
+			code: "GTFS_QUERY_INVALID",
+			category: "query",
+			details: {
+				field: "date",
+				value: query.date
+			}
+		});
+		const serviceIds = getServiceIdsByDate(query.date, options);
+		whereClauses.push(`service_id IN (${serviceIds.map((id) => sqlString.escape(id)).join(",")})`);
+	}
+	if (whereClauses.length > 0) whereClause = `WHERE ${whereClauses.join(" AND ")}`;
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-plus/calendar-attributes.ts
+function getCalendarAttributes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "calendar_attributes";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-plus/directions.ts
+function getDirections(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "directions";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/non-standard/timetables.ts
+function getTimetables(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "timetables";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/non-standard/timetable-stop-order.ts
+function getTimetableStopOrders(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "timetable_stop_order";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/non-standard/timetable-pages.ts
+function getTimetablePages(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "timetable_pages";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/non-standard/timetable-notes.ts
+function getTimetableNotes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "timetable_notes";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/non-standard/timetable-notes-references.ts
+function getTimetableNotesReferences(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "timetable_notes_references";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/non-standard/trips-dated-vehicle-journey.ts
+function getTripsDatedVehicleJourneys(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "trips_dated_vehicle_journey";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-ride/board-alights.ts
+function getBoardAlights(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "board_alight";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-ride/ride-feed-info.ts
+function getRideFeedInfo(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "ride_feed_info";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-ride/rider-trips.ts
+function getRiderTrips(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "rider_trip";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-ride/ridership.ts
+function getRidership(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "ridership";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-ride/trip-capacities.ts
+function getTripCapacities(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "trip_capacity";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-realtime/stop-time-updates.ts
+function getStopTimeUpdates(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "stop_time_updates";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-realtime/trip-updates.ts
+function getTripUpdates(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "trip_updates";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-realtime/vehicle-positions.ts
+function getVehiclePositions(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "vehicle_positions";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/gtfs-realtime/service-alerts.ts
+const ENTITY_COLUMNS = new Set([
+	"alert_id",
+	"stop_id",
+	"route_id",
+	"route_type",
+	"trip_id",
+	"direction_id"
+]);
+function getServiceAlerts(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "service_alerts";
+	const joinTableName = "service_alert_informed_entities";
+	const selectClause = formatSelectClause(fields);
+	const orderByClause = formatOrderByClause(orderBy);
+	const alertQuery = {};
+	const entityQuery = {};
+	for (const [key, value] of Object.entries(query)) if (ENTITY_COLUMNS.has(key)) entityQuery[key] = value;
+	else alertQuery[key] = value;
+	const whereClause = formatWhereClauses(alertQuery);
+	const alerts = db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+	const alertIds = alerts.map((alert) => alert.id);
+	if (alertIds.length === 0) return [];
+	const alertIdPlaceholders = alertIds.map(() => "?").join(", ");
+	const entityFilterClause = formatWhereClauses(entityQuery);
+	const entityWhereClause = entityFilterClause ? `${entityFilterClause} AND alert_id IN (${alertIdPlaceholders})` : `WHERE alert_id IN (${alertIdPlaceholders})`;
+	const entities = db.prepare(`SELECT * FROM ${joinTableName} ${entityWhereClause};`).all(...alertIds);
+	const entitiesByAlertId = /* @__PURE__ */ new Map();
+	for (const entity of entities) {
+		const group = entitiesByAlertId.get(entity.alert_id);
+		if (group) group.push(entity);
+		else entitiesByAlertId.set(entity.alert_id, [entity]);
+	}
+	return (Object.keys(entityQuery).length > 0 ? alerts.filter((alert) => entitiesByAlertId.has(alert.id)) : alerts).map((alert) => ({
+		...alert,
+		informed_entities: entitiesByAlertId.get(alert.id) ?? []
+	}));
+}
+
+//#endregion
+//#region src/lib/gtfs-realtime/service-alert-informed-entities.ts
+function getServiceAlertInformedEntities(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "service_alert_informed_entities";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/ods/deadheads.ts
+function getDeadheads(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "deadheads";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/ods/deadhead-times.ts
+function getDeadheadTimes(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "deadhead_times";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/ods/ops-locations.ts
+function getOpsLocations(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "ops_locations";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/ods/run-events.ts
+function getRunEvents(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "run_events";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+//#region src/lib/ods/runs-pieces.ts
+function getRunsPieces(query = {}, fields = [], orderBy = [], options = {}) {
+	const db = options.db ?? openDb();
+	const tableName = "runs_pieces";
+	const selectClause = formatSelectClause(fields);
+	const whereClause = formatWhereClauses(query);
+	const orderByClause = formatOrderByClause(orderBy);
+	return db.prepare(`${selectClause} FROM ${tableName} ${whereClause} ${orderByClause};`).all();
+}
+
+//#endregion
+export { getCalendars as $, getStopsAsGeoJSON as A, getNetworks as B, getCalendarAttributes as C, untildify as Ct, getTimeframes as D, getTransfers as E, getRouteAttributes as F, getFrequencies as G, getLocationGroupStops as H, getRoutes as I, getFareRules as J, getFeedInfo as K, getRouteNetworks as L, getStopAreas as M, getShapes as N, getStoptimes as O, getShapesAsGeoJSON as P, getFareAttributes as Q, getRiderCategories as R, getDirections as S, prepDirectory as St, getTranslations as T, formatError as Tt, getLocationGroups as U, getLocations as V, getLevels as W, getFareMedia as X, getFareProducts as Y, getFareLegRules as Z, getTimetableNotesReferences as _, formatGtfsError as _t, getDeadheads as a, getAgencies as at, getTimetableStopOrders as b, generateFolderName as bt, getVehiclePositions as c, importGtfs as ct, getTripCapacities as d, deleteDb as dt, getServiceIdsByDate as et, getRidership as f, openDb as ft, getTripsDatedVehicleJourneys as g, GtfsWarningCode as gt, getBoardAlights as h, GtfsErrorCode as ht, getDeadheadTimes as i, getAreas as it, getStopAttributes as j, getStops as k, getTripUpdates as l, updateGtfsRealtime as lt, getRideFeedInfo as m, GtfsErrorCategory as mt, getRunEvents as n, getBookingRules as nt, getServiceAlertInformedEntities as o, advancedQuery as ot, getRiderTrips as p, GtfsError as pt, getFareTransferRules as q, getOpsLocations as r, getAttributions as rt, getServiceAlerts as s, exportGtfs as st, getRunsPieces as t, getCalendarDates as tt, getStopTimeUpdates as u, closeDb as ut, getTimetableNotes as v, isGtfsError as vt, getTrips as w, unzip as wt, getTimetables as x, getConfig as xt, getTimetablePages as y, isGtfsValidationError as yt, getPathways as z };
+//# sourceMappingURL=src-DuXcyA_N.js.map