minotor 7.0.2 → 9.0.0

package/dist/parser.cjs.js

@@ -7,58 +7,6 @@ var require$$3 = require('events');
 var require$$4 = require('zlib');
 var require$$5 = require('stream');
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __asyncValues(o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -11554,14 +11502,13 @@ const Stop = {
             sourceStopId: isSet$1(object.sourceStopId) ? globalThis.String(object.sourceStopId) : "",
             lat: isSet$1(object.lat) ? globalThis.Number(object.lat) : undefined,
             lon: isSet$1(object.lon) ? globalThis.Number(object.lon) : undefined,
-            children: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.children) ? object.children.map((e) => globalThis.Number(e)) : [],
+            children: globalThis.Array.isArray(object?.children) ? object.children.map((e) => globalThis.Number(e)) : [],
             parent: isSet$1(object.parent) ? globalThis.Number(object.parent) : undefined,
             locationType: isSet$1(object.locationType) ? locationTypeFromJSON(object.locationType) : 0,
             platform: isSet$1(object.platform) ? globalThis.String(object.platform) : undefined,
         };
     },
     toJSON(message) {
-        var _a;
         const obj = {};
         if (message.name !== "") {
             obj.name = message.name;
@@ -11575,7 +11522,7 @@ const Stop = {
         if (message.lon !== undefined) {
             obj.lon = message.lon;
         }
-        if ((_a = message.children) === null || _a === void 0 ? void 0 : _a.length) {
+        if (message.children?.length) {
             obj.children = message.children.map((e) => Math.round(e));
         }
         if (message.parent !== undefined) {
@@ -11590,19 +11537,18 @@ const Stop = {
         return obj;
     },
     create(base) {
-        return Stop.fromPartial(base !== null && base !== void 0 ? base : {});
+        return Stop.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
         const message = createBaseStop();
-        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
-        message.sourceStopId = (_b = object.sourceStopId) !== null && _b !== void 0 ? _b : "";
-        message.lat = (_c = object.lat) !== null && _c !== void 0 ? _c : undefined;
-        message.lon = (_d = object.lon) !== null && _d !== void 0 ? _d : undefined;
-        message.children = ((_e = object.children) === null || _e === void 0 ? void 0 : _e.map((e) => e)) || [];
-        message.parent = (_f = object.parent) !== null && _f !== void 0 ? _f : undefined;
-        message.locationType = (_g = object.locationType) !== null && _g !== void 0 ? _g : 0;
-        message.platform = (_h = object.platform) !== null && _h !== void 0 ? _h : undefined;
+        message.name = object.name ?? "";
+        message.sourceStopId = object.sourceStopId ?? "";
+        message.lat = object.lat ?? undefined;
+        message.lon = object.lon ?? undefined;
+        message.children = object.children?.map((e) => e) || [];
+        message.parent = object.parent ?? undefined;
+        message.locationType = object.locationType ?? 0;
+        message.platform = object.platform ?? undefined;
         return message;
     },
 };
@@ -11651,28 +11597,26 @@ const StopsMap = {
     fromJSON(object) {
         return {
             version: isSet$1(object.version) ? globalThis.String(object.version) : "",
-            stops: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.stops) ? object.stops.map((e) => Stop.fromJSON(e)) : [],
+            stops: globalThis.Array.isArray(object?.stops) ? object.stops.map((e) => Stop.fromJSON(e)) : [],
         };
     },
     toJSON(message) {
-        var _a;
         const obj = {};
         if (message.version !== "") {
             obj.version = message.version;
         }
-        if ((_a = message.stops) === null || _a === void 0 ? void 0 : _a.length) {
+        if (message.stops?.length) {
             obj.stops = message.stops.map((e) => Stop.toJSON(e));
         }
         return obj;
     },
     create(base) {
-        return StopsMap.fromPartial(base !== null && base !== void 0 ? base : {});
+        return StopsMap.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b;
         const message = createBaseStopsMap();
-        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : "";
-        message.stops = ((_b = object.stops) === null || _b === void 0 ? void 0 : _b.map((e) => Stop.fromPartial(e))) || [];
+        message.version = object.version ?? "";
+        message.stops = object.stops?.map((e) => Stop.fromPartial(e)) || [];
         return message;
     },
 };
@@ -11756,8 +11700,12 @@ const serializeLocationType = (locationType) => {
  * to efficiently find stops based on user queries.
  */
 class StopsIndex {
+    stops;
+    sourceStopsMap;
+    textIndex;
+    geoIndex;
+    stopPoints;
     constructor(stops) {
-        var _a;
         this.stops = stops;
         this.sourceStopsMap = new Map();
         const stopsSet = new Map();
@@ -11766,7 +11714,7 @@ class StopsIndex {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const stop = stops[id];
             this.sourceStopsMap.set(stop.sourceStopId, id);
-            const effectiveStopId = (_a = stop.parent) !== null && _a !== void 0 ? _a : id;
+            const effectiveStopId = stop.parent ?? id;
             if (!stopsSet.has(effectiveStopId)) {
                 stopsSet.set(effectiveStopId, {
                     id: effectiveStopId,
@@ -11881,7 +11829,6 @@ class StopsIndex {
      * Find ids of all sibling stops.
      */
     equivalentStops(sourceId) {
-        var _a, _b;
         const id = this.sourceStopsMap.get(sourceId);
         if (id === undefined) {
             return [];
@@ -11891,13 +11838,14 @@ class StopsIndex {
             return [];
         }
         const equivalentStops = stop.parent
-            ? ((_b = (_a = this.stops[stop.parent]) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [])
+            ? (this.stops[stop.parent]?.children ?? [])
             : stop.children;
         return Array.from(new Set([id, ...equivalentStops])).map((stopId) => this.stops[stopId]);
     }
 }
 
 class Duration {
+    totalSeconds;
     constructor(totalSeconds) {
         this.totalSeconds = totalSeconds;
     }
@@ -12200,15 +12148,14 @@ const Route$1 = {
         return obj;
     },
     create(base) {
-        return Route$1.fromPartial(base !== null && base !== void 0 ? base : {});
+        return Route$1.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d;
         const message = createBaseRoute();
-        message.stopTimes = (_a = object.stopTimes) !== null && _a !== void 0 ? _a : new Uint8Array(0);
-        message.pickUpDropOffTypes = (_b = object.pickUpDropOffTypes) !== null && _b !== void 0 ? _b : new Uint8Array(0);
-        message.stops = (_c = object.stops) !== null && _c !== void 0 ? _c : new Uint8Array(0);
-        message.serviceRouteId = (_d = object.serviceRouteId) !== null && _d !== void 0 ? _d : 0;
+        message.stopTimes = object.stopTimes ?? new Uint8Array(0);
+        message.pickUpDropOffTypes = object.pickUpDropOffTypes ?? new Uint8Array(0);
+        message.stops = object.stops ?? new Uint8Array(0);
+        message.serviceRouteId = object.serviceRouteId ?? 0;
         return message;
     },
 };
@@ -12285,52 +12232,227 @@ const Transfer = {
         return obj;
     },
     create(base) {
-        return Transfer.fromPartial(base !== null && base !== void 0 ? base : {});
+        return Transfer.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c;
         const message = createBaseTransfer();
-        message.destination = (_a = object.destination) !== null && _a !== void 0 ? _a : 0;
-        message.type = (_b = object.type) !== null && _b !== void 0 ? _b : 0;
-        message.minTransferTime = (_c = object.minTransferTime) !== null && _c !== void 0 ? _c : undefined;
+        message.destination = object.destination ?? 0;
+        message.type = object.type ?? 0;
+        message.minTransferTime = object.minTransferTime ?? undefined;
         return message;
     },
 };
-function createBaseStopAdjacency() {
-    return { transfers: [], routes: [] };
+function createBaseTripBoarding() {
+    return { hopOnStopIndex: 0, routeId: 0, tripIndex: 0 };
 }
-const StopAdjacency = {
+const TripBoarding = {
     encode(message, writer = new BinaryWriter()) {
-        for (const v of message.transfers) {
-            Transfer.encode(v, writer.uint32(10).fork()).join();
+        if (message.hopOnStopIndex !== 0) {
+            writer.uint32(8).uint32(message.hopOnStopIndex);
         }
-        writer.uint32(18).fork();
-        for (const v of message.routes) {
-            writer.uint32(v);
+        if (message.routeId !== 0) {
+            writer.uint32(16).uint32(message.routeId);
+        }
+        if (message.tripIndex !== 0) {
+            writer.uint32(24).uint32(message.tripIndex);
         }
-        writer.join();
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
         const end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseStopAdjacency();
+        const message = createBaseTripBoarding();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1: {
-                    if (tag !== 10) {
+                    if (tag !== 8) {
                         break;
                     }
-                    message.transfers.push(Transfer.decode(reader, reader.uint32()));
+                    message.hopOnStopIndex = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.routeId = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.tripIndex = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            hopOnStopIndex: isSet(object.hopOnStopIndex) ? globalThis.Number(object.hopOnStopIndex) : 0,
+            routeId: isSet(object.routeId) ? globalThis.Number(object.routeId) : 0,
+            tripIndex: isSet(object.tripIndex) ? globalThis.Number(object.tripIndex) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.hopOnStopIndex !== 0) {
+            obj.hopOnStopIndex = Math.round(message.hopOnStopIndex);
+        }
+        if (message.routeId !== 0) {
+            obj.routeId = Math.round(message.routeId);
+        }
+        if (message.tripIndex !== 0) {
+            obj.tripIndex = Math.round(message.tripIndex);
+        }
+        return obj;
+    },
+    create(base) {
+        return TripBoarding.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTripBoarding();
+        message.hopOnStopIndex = object.hopOnStopIndex ?? 0;
+        message.routeId = object.routeId ?? 0;
+        message.tripIndex = object.tripIndex ?? 0;
+        return message;
+    },
+};
+function createBaseTripContinuationEntry() {
+    return { originStopIndex: 0, originRouteId: 0, originTripIndex: 0, continuations: [] };
+}
+const TripContinuationEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.originStopIndex !== 0) {
+            writer.uint32(8).uint32(message.originStopIndex);
+        }
+        if (message.originRouteId !== 0) {
+            writer.uint32(16).uint32(message.originRouteId);
+        }
+        if (message.originTripIndex !== 0) {
+            writer.uint32(24).uint32(message.originTripIndex);
+        }
+        for (const v of message.continuations) {
+            TripBoarding.encode(v, writer.uint32(34).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTripContinuationEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.originStopIndex = reader.uint32();
                     continue;
                 }
                 case 2: {
-                    if (tag === 16) {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.originRouteId = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.originTripIndex = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.continuations.push(TripBoarding.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            originStopIndex: isSet(object.originStopIndex) ? globalThis.Number(object.originStopIndex) : 0,
+            originRouteId: isSet(object.originRouteId) ? globalThis.Number(object.originRouteId) : 0,
+            originTripIndex: isSet(object.originTripIndex) ? globalThis.Number(object.originTripIndex) : 0,
+            continuations: globalThis.Array.isArray(object?.continuations)
+                ? object.continuations.map((e) => TripBoarding.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.originStopIndex !== 0) {
+            obj.originStopIndex = Math.round(message.originStopIndex);
+        }
+        if (message.originRouteId !== 0) {
+            obj.originRouteId = Math.round(message.originRouteId);
+        }
+        if (message.originTripIndex !== 0) {
+            obj.originTripIndex = Math.round(message.originTripIndex);
+        }
+        if (message.continuations?.length) {
+            obj.continuations = message.continuations.map((e) => TripBoarding.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return TripContinuationEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTripContinuationEntry();
+        message.originStopIndex = object.originStopIndex ?? 0;
+        message.originRouteId = object.originRouteId ?? 0;
+        message.originTripIndex = object.originTripIndex ?? 0;
+        message.continuations = object.continuations?.map((e) => TripBoarding.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseStopAdjacency() {
+    return { routes: [], transfers: [] };
+}
+const StopAdjacency = {
+    encode(message, writer = new BinaryWriter()) {
+        writer.uint32(10).fork();
+        for (const v of message.routes) {
+            writer.uint32(v);
+        }
+        writer.join();
+        for (const v of message.transfers) {
+            Transfer.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStopAdjacency();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag === 8) {
                         message.routes.push(reader.uint32());
                         continue;
                     }
-                    if (tag === 18) {
+                    if (tag === 10) {
                         const end2 = reader.uint32() + reader.pos;
                         while (reader.pos < end2) {
                             message.routes.push(reader.uint32());
@@ -12339,6 +12461,13 @@ const StopAdjacency = {
                     }
                     break;
                 }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.transfers.push(Transfer.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -12349,31 +12478,29 @@ const StopAdjacency = {
     },
     fromJSON(object) {
         return {
-            transfers: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.transfers)
+            routes: globalThis.Array.isArray(object?.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
+            transfers: globalThis.Array.isArray(object?.transfers)
                 ? object.transfers.map((e) => Transfer.fromJSON(e))
                 : [],
-            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
         };
     },
     toJSON(message) {
-        var _a, _b;
         const obj = {};
-        if ((_a = message.transfers) === null || _a === void 0 ? void 0 : _a.length) {
-            obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
-        }
-        if ((_b = message.routes) === null || _b === void 0 ? void 0 : _b.length) {
+        if (message.routes?.length) {
             obj.routes = message.routes.map((e) => Math.round(e));
         }
+        if (message.transfers?.length) {
+            obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
+        }
         return obj;
     },
     create(base) {
-        return StopAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
+        return StopAdjacency.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b;
         const message = createBaseStopAdjacency();
-        message.transfers = ((_a = object.transfers) === null || _a === void 0 ? void 0 : _a.map((e) => Transfer.fromPartial(e))) || [];
-        message.routes = ((_b = object.routes) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
+        message.routes = object.routes?.map((e) => e) || [];
+        message.transfers = object.transfers?.map((e) => Transfer.fromPartial(e)) || [];
         return message;
     },
 };
@@ -12442,11 +12569,10 @@ const ServiceRoute = {
         return {
             type: isSet(object.type) ? routeTypeFromJSON(object.type) : 0,
             name: isSet(object.name) ? globalThis.String(object.name) : "",
-            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
+            routes: globalThis.Array.isArray(object?.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
         };
     },
     toJSON(message) {
-        var _a;
         const obj = {};
         if (message.type !== 0) {
             obj.type = routeTypeToJSON(message.type);
@@ -12454,25 +12580,24 @@ const ServiceRoute = {
         if (message.name !== "") {
             obj.name = message.name;
         }
-        if ((_a = message.routes) === null || _a === void 0 ? void 0 : _a.length) {
+        if (message.routes?.length) {
             obj.routes = message.routes.map((e) => Math.round(e));
         }
         return obj;
     },
     create(base) {
-        return ServiceRoute.fromPartial(base !== null && base !== void 0 ? base : {});
+        return ServiceRoute.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c;
         const message = createBaseServiceRoute();
-        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
-        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
-        message.routes = ((_c = object.routes) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
+        message.type = object.type ?? 0;
+        message.name = object.name ?? "";
+        message.routes = object.routes?.map((e) => e) || [];
         return message;
     },
 };
 function createBaseTimetable() {
-    return { version: "", stopsAdjacency: [], routesAdjacency: [], serviceRoutes: [] };
+    return { version: "", stopsAdjacency: [], routesAdjacency: [], serviceRoutes: [], tripContinuations: [] };
 }
 const Timetable$1 = {
     encode(message, writer = new BinaryWriter()) {
@@ -12488,6 +12613,9 @@ const Timetable$1 = {
         for (const v of message.serviceRoutes) {
             ServiceRoute.encode(v, writer.uint32(34).fork()).join();
         }
+        for (const v of message.tripContinuations) {
+            TripContinuationEntry.encode(v, writer.uint32(42).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -12525,6 +12653,13 @@ const Timetable$1 = {
                     message.serviceRoutes.push(ServiceRoute.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.tripContinuations.push(TripContinuationEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -12536,44 +12671,49 @@ const Timetable$1 = {
     fromJSON(object) {
         return {
             version: isSet(object.version) ? globalThis.String(object.version) : "",
-            stopsAdjacency: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.stopsAdjacency)
+            stopsAdjacency: globalThis.Array.isArray(object?.stopsAdjacency)
                 ? object.stopsAdjacency.map((e) => StopAdjacency.fromJSON(e))
                 : [],
-            routesAdjacency: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routesAdjacency)
+            routesAdjacency: globalThis.Array.isArray(object?.routesAdjacency)
                 ? object.routesAdjacency.map((e) => Route$1.fromJSON(e))
                 : [],
-            serviceRoutes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.serviceRoutes)
+            serviceRoutes: globalThis.Array.isArray(object?.serviceRoutes)
                 ? object.serviceRoutes.map((e) => ServiceRoute.fromJSON(e))
                 : [],
+            tripContinuations: globalThis.Array.isArray(object?.tripContinuations)
+                ? object.tripContinuations.map((e) => TripContinuationEntry.fromJSON(e))
+                : [],
         };
     },
     toJSON(message) {
-        var _a, _b, _c;
         const obj = {};
         if (message.version !== "") {
             obj.version = message.version;
         }
-        if ((_a = message.stopsAdjacency) === null || _a === void 0 ? void 0 : _a.length) {
+        if (message.stopsAdjacency?.length) {
             obj.stopsAdjacency = message.stopsAdjacency.map((e) => StopAdjacency.toJSON(e));
         }
-        if ((_b = message.routesAdjacency) === null || _b === void 0 ? void 0 : _b.length) {
+        if (message.routesAdjacency?.length) {
             obj.routesAdjacency = message.routesAdjacency.map((e) => Route$1.toJSON(e));
         }
-        if ((_c = message.serviceRoutes) === null || _c === void 0 ? void 0 : _c.length) {
+        if (message.serviceRoutes?.length) {
             obj.serviceRoutes = message.serviceRoutes.map((e) => ServiceRoute.toJSON(e));
         }
+        if (message.tripContinuations?.length) {
+            obj.tripContinuations = message.tripContinuations.map((e) => TripContinuationEntry.toJSON(e));
+        }
         return obj;
     },
     create(base) {
-        return Timetable$1.fromPartial(base !== null && base !== void 0 ? base : {});
+        return Timetable$1.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d;
         const message = createBaseTimetable();
-        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : "";
-        message.stopsAdjacency = ((_b = object.stopsAdjacency) === null || _b === void 0 ? void 0 : _b.map((e) => StopAdjacency.fromPartial(e))) || [];
-        message.routesAdjacency = ((_c = object.routesAdjacency) === null || _c === void 0 ? void 0 : _c.map((e) => Route$1.fromPartial(e))) || [];
-        message.serviceRoutes = ((_d = object.serviceRoutes) === null || _d === void 0 ? void 0 : _d.map((e) => ServiceRoute.fromPartial(e))) || [];
+        message.version = object.version ?? "";
+        message.stopsAdjacency = object.stopsAdjacency?.map((e) => StopAdjacency.fromPartial(e)) || [];
+        message.routesAdjacency = object.routesAdjacency?.map((e) => Route$1.fromPartial(e)) || [];
+        message.serviceRoutes = object.serviceRoutes?.map((e) => ServiceRoute.fromPartial(e)) || [];
+        message.tripContinuations = object.tripContinuations?.map((e) => TripContinuationEntry.fromPartial(e)) || [];
         return message;
     },
 };
@@ -12610,6 +12750,11 @@ function isSet(value) {
  * A class representing a time as minutes since midnight.
  */
 class Time {
+    /*
+     * Number of minutes since midnight.
+     Note that this value can go beyond 3600 to model services overlapping with the next day.
+     */
+    minutesSinceMidnight;
     /**
      * Gets the infinity time as a Time instance.
      * This represents a time that is conceptually beyond any real possible time.
@@ -12862,7 +13007,53 @@ const toPickupDropOffType = (numericalType) => {
  * A route identifies all trips of a given service route sharing the same list of stops.
  */
 class Route {
-    constructor(stopTimes, pickUpDropOffTypes, stops, serviceRouteId) {
+    id;
+    /**
+     * Arrivals and departures encoded as minutes from midnight.
+     * Format: [arrival1, departure1, arrival2, departure2, etc.]
+     */
+    stopTimes;
+    /**
+     * PickUp and DropOff types represented as a 2-bit encoded Uint8Array.
+     * Values (2 bits each):
+     *   0: REGULAR
+     *   1: NOT_AVAILABLE
+     *   2: MUST_PHONE_AGENCY
+     *   3: MUST_COORDINATE_WITH_DRIVER
+     *
+     * Encoding format: Each byte contains 2 pickup/drop-off pairs (4 bits each)
+     * Bit layout per byte: [pickup_1 (2 bits)][drop_off_1 (2 bits)][pickup_0 (2 bits)][drop_off_0 (2 bits)]
+     * Example: For stops 0 and 1 in a trip, one byte encodes all 4 values
+     */
+    pickUpDropOffTypes;
+    /**
+     * A binary array of stopIds in the route.
+     * [stop1, stop2, stop3,...]
+     */
+    stops;
+    /**
+     * A reverse mapping of each stop with their index in the route:
+     * {
+     *   4: 0,
+     *   5: 1,
+     *   ...
+     * }
+     */
+    stopIndices;
+    /**
+     * The identifier of the route as a service shown to users.
+     */
+    serviceRouteId;
+    /**
+     * The total number of stops in the route.
+     */
+    nbStops;
+    /**
+     * The total number of trips in the route.
+     */
+    nbTrips;
+    constructor(id, stopTimes, pickUpDropOffTypes, stops, serviceRouteId) {
+        this.id = id;
         this.stopTimes = stopTimes;
         this.pickUpDropOffTypes = pickUpDropOffTypes;
         this.stops = stops;
@@ -12872,9 +13063,87 @@ class Route {
         this.stopIndices = new Map();
         for (let i = 0; i < stops.length; i++) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.stopIndices.set(stops[i], i);
+            const stopId = stops[i];
+            const existingIndices = this.stopIndices.get(stopId);
+            if (existingIndices) {
+                existingIndices.push(i);
+            }
+            else {
+                this.stopIndices.set(stopId, [i]);
+            }
         }
     }
+    /**
+     * Creates a new route from multiple trips with their stops.
+     *
+     * @param params The route parameters including ID, service route ID, and trips.
+     * @returns The new route.
+     */
+    static of(params) {
+        const { id, serviceRouteId, trips } = params;
+        if (trips.length === 0) {
+            throw new Error('At least one trip must be provided');
+        }
+        // All trips must have the same stops in the same order
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const firstTrip = trips[0];
+        const stopIds = new Uint32Array(firstTrip.stops.map((stop) => stop.id));
+        const numStops = stopIds.length;
+        // Validate all trips have the same stops
+        for (let tripIndex = 1; tripIndex < trips.length; tripIndex++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const trip = trips[tripIndex];
+            if (trip.stops.length !== numStops) {
+                throw new Error(`Trip ${tripIndex} has ${trip.stops.length} stops, expected ${numStops}`);
+            }
+            for (let stopIndex = 0; stopIndex < numStops; stopIndex++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (trip.stops[stopIndex].id !== stopIds[stopIndex]) {
+                    throw new Error(`Trip ${tripIndex} has different stop at index ${stopIndex}`);
+                }
+            }
+        }
+        // Create stopTimes array with arrivals and departures for all trips
+        const stopTimes = new Uint16Array(trips.length * numStops * 2);
+        for (let tripIndex = 0; tripIndex < trips.length; tripIndex++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const trip = trips[tripIndex];
+            for (let stopIndex = 0; stopIndex < numStops; stopIndex++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const stop = trip.stops[stopIndex];
+                const baseIndex = (tripIndex * numStops + stopIndex) * 2;
+                stopTimes[baseIndex] = stop.arrivalTime.toMinutes();
+                stopTimes[baseIndex + 1] = stop.departureTime.toMinutes();
+            }
+        }
+        // Create pickUpDropOffTypes array (2-bit encoded) for all trips
+        const totalStopEntries = trips.length * numStops;
+        const pickUpDropOffTypes = new Uint8Array(Math.ceil(totalStopEntries / 2));
+        for (let tripIndex = 0; tripIndex < trips.length; tripIndex++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const trip = trips[tripIndex];
+            for (let stopIndex = 0; stopIndex < numStops; stopIndex++) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const stop = trip.stops[stopIndex];
+                const globalIndex = tripIndex * numStops + stopIndex;
+                const pickUp = stop.pickUpType ?? REGULAR;
+                const dropOff = stop.dropOffType ?? REGULAR;
+                const byteIndex = Math.floor(globalIndex / 2);
+                const isSecondPair = globalIndex % 2 === 1;
+                if (isSecondPair) {
+                    // Second pair: pickup in upper 2 bits, dropOff in bits 4-5
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    pickUpDropOffTypes[byteIndex] |= (pickUp << 6) | (dropOff << 4);
+                }
+                else {
+                    // First pair: pickup in bits 2-3, dropOff in lower 2 bits
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    pickUpDropOffTypes[byteIndex] |= (pickUp << 2) | dropOff;
+                }
+            }
+        }
+        return new Route(id, stopTimes, pickUpDropOffTypes, stopIds, serviceRouteId);
+    }
     /**
      * Serializes the Route into binary arrays.
      *
@@ -12888,24 +13157,6 @@ class Route {
             serviceRouteId: this.serviceRouteId,
         };
     }
-    /**
-     * Checks if stop A is before stop B in the route.
-     *
-     * @param stopA - The StopId of the first stop.
-     * @param stopB - The StopId of the second stop.
-     * @returns True if stop A is before stop B, false otherwise.
-     */
-    isBefore(stopA, stopB) {
-        const stopAIndex = this.stopIndices.get(stopA);
-        if (stopAIndex === undefined) {
-            throw new Error(`Stop index ${stopAIndex} not found in route ${this.serviceRouteId}`);
-        }
-        const stopBIndex = this.stopIndices.get(stopB);
-        if (stopBIndex === undefined) {
-            throw new Error(`Stop index ${stopBIndex} not found in route ${this.serviceRouteId}`);
-        }
-        return stopAIndex < stopBIndex;
-    }
     /**
      * Retrieves the number of stops in the route.
      *
@@ -12914,6 +13165,14 @@ class Route {
     getNbStops() {
         return this.nbStops;
     }
+    /**
+     * Retrieves the number of trips in the route.
+     *
+     * @returns The total number of trips in the route.
+     */
+    getNbTrips() {
+        return this.nbTrips;
+    }
     /**
      * Finds the ServiceRouteId of the route. It corresponds the identifier
      * of the service shown to the end user as a route.
@@ -12926,47 +13185,47 @@ class Route {
     /**
      * Retrieves the arrival time at a specific stop for a given trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The arrival time at the specified stop and trip as a Time object.
      */
-    arrivalAt(stopId, tripIndex) {
-        const arrivalIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2;
+    arrivalAt(stopIndex, tripIndex) {
+        const arrivalIndex = (tripIndex * this.stops.length + stopIndex) * 2;
         const arrival = this.stopTimes[arrivalIndex];
         if (arrival === undefined) {
-            throw new Error(`Arrival time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Arrival time not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         return Time.fromMinutes(arrival);
     }
     /**
      * Retrieves the departure time at a specific stop for a given trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The departure time at the specified stop and trip as a Time object.
      */
-    departureFrom(stopId, tripIndex) {
-        const departureIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2 + 1;
+    departureFrom(stopIndex, tripIndex) {
+        const departureIndex = (tripIndex * this.stops.length + stopIndex) * 2 + 1;
         const departure = this.stopTimes[departureIndex];
         if (departure === undefined) {
-            throw new Error(`Departure time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Departure time not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         return Time.fromMinutes(departure);
     }
     /**
      * Retrieves the pick-up type for a specific stop and trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The pick-up type at the specified stop and trip.
      */
-    pickUpTypeFrom(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+    pickUpTypeFrom(stopIndex, tripIndex) {
+        const globalIndex = tripIndex * this.stops.length + stopIndex;
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
         if (byte === undefined) {
-            throw new Error(`Pick up type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Pick up type not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         const pickUpValue = isSecondPair
             ? (byte >> 6) & 0x03 // Upper 2 bits for second pair
@@ -12976,17 +13235,17 @@ class Route {
     /**
      * Retrieves the drop-off type for a specific stop and trip.
      *
-     * @param stopId - The identifier of the stop.
+     * @param stopIndex - The index of the stop in the route.
      * @param tripIndex - The index of the trip.
      * @returns The drop-off type at the specified stop and trip.
      */
-    dropOffTypeAt(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+    dropOffTypeAt(stopIndex, tripIndex) {
+        const globalIndex = tripIndex * this.stops.length + stopIndex;
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
         if (byte === undefined) {
-            throw new Error(`Drop off type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
+            throw new Error(`Drop off type not found for stop ${this.stopId(stopIndex)} (${stopIndex}) at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
         const dropOffValue = isSecondPair
             ? (byte >> 4) & 0x03 // Bits 4-5 for second pair
@@ -12998,14 +13257,14 @@ class Route {
      * optionally constrained by a latest trip index and a time before which the trip
      * should not depart.
      * *
-     * @param stopId - The StopId of the stop where the trip should be found.
+     * @param stopIndex - The route index of the stop where the trip should be found.
      * @param [after=Time.origin()] - The earliest time after which the trip should depart.
      *                                    If not provided, searches all available trips.
      * @param [beforeTrip] - (Optional) The index of the trip before which the search should be constrained.
      *                                   If not provided, searches all available trips.
      * @returns The index of the earliest trip meeting the criteria, or undefined if no such trip is found.
      */
-    findEarliestTrip(stopId, after = Time.origin(), beforeTrip) {
+    findEarliestTrip(stopIndex, after = Time.origin(), beforeTrip) {
         if (this.nbTrips <= 0)
             return undefined;
         let hi = this.nbTrips - 1;
@@ -13017,7 +13276,7 @@ class Route {
         let lb = -1;
         while (lo <= hi) {
             const mid = (lo + hi) >>> 1;
-            const depMid = this.departureFrom(stopId, mid);
+            const depMid = this.departureFrom(stopIndex, mid);
             if (depMid.isBefore(after)) {
                 lo = mid + 1;
             }
@@ -13028,8 +13287,8 @@ class Route {
         }
         if (lb === -1)
             return undefined;
-        for (let t = lb; t < (beforeTrip !== null && beforeTrip !== void 0 ? beforeTrip : this.nbTrips); t++) {
-            const pickup = this.pickUpTypeFrom(stopId, t);
+        for (let t = lb; t < (beforeTrip ?? this.nbTrips); t++) {
+            const pickup = this.pickUpTypeFrom(stopIndex, t);
             if (pickup !== 'NOT_AVAILABLE') {
                 return t;
             }
@@ -13037,19 +13296,76 @@ class Route {
         return undefined;
     }
     /**
-     * Retrieves the index of a stop within the route.
+     * Retrieves the indices of a stop within the route.
      * @param stopId The StopId of the stop to locate in the route.
-     * @returns The index of the stop in the route.
+     * @returns An array of indices where the stop appears in the route, or an empty array if the stop is not found.
      */
-    stopIndex(stopId) {
+    stopRouteIndices(stopId) {
         const stopIndex = this.stopIndices.get(stopId);
         if (stopIndex === undefined) {
-            throw new Error(`Stop index for ${stopId} not found in route ${this.serviceRouteId}`);
+            return [];
         }
         return stopIndex;
     }
+    /**
+     * Retrieves the id of a stop at a given index in a route.
+     * @param stopRouteIndex The route index of the stop.
+     * @returns The id of the stop at the given index in the route.
+     */
+    stopId(stopRouteIndex) {
+        const stopId = this.stops[stopRouteIndex];
+        if (stopId === undefined) {
+            throw new Error(`StopId for stop at index ${stopRouteIndex} not found in route ${this.serviceRouteId}`);
+        }
+        return stopId;
+    }
 }
 
+// Each value uses 20 bits, allowing values from 0 to 1,048,575 (2^20 - 1)
+const VALUE_MASK = (1n << 20n) - 1n; // 0xFFFFF
+const MAX_VALUE = 1_048_575; // 2^20 - 1
+// Bit positions for each value in the 60-bit bigint
+const TRIP_INDEX_SHIFT = 0n;
+const ROUTE_ID_SHIFT = 20n;
+const STOP_INDEX_SHIFT = 40n;
+/**
+ * Validates that a value fits within 20 bits (0 to 1,048,575)
+ * @param value - The value to validate
+ * @param name - The name of the value for error reporting
+ * @throws Error if the value is out of range
+ */
+const validateValue = (value, name) => {
+    if (value < 0 || value > MAX_VALUE) {
+        throw new Error(`${name} must be between 0 and ${MAX_VALUE}, got ${value}`);
+    }
+};
+/**
+ * Encodes a stop index, route ID, and trip index into a single trip boarding ID.
+ * @param stopIndex - The index of the stop within the route (0 to 1,048,575)
+ * @param routeId - The route identifier (0 to 1,048,575)
+ * @param tripIndex - The index of the trip within the route (0 to 1,048,575)
+ * @returns The encoded trip ID as a bigint
+ */
+const encode = (stopIndex, routeId, tripIndex) => {
+    validateValue(stopIndex, 'stopIndex');
+    validateValue(routeId, 'routeId');
+    validateValue(tripIndex, 'tripIndex');
+    return ((BigInt(stopIndex) << STOP_INDEX_SHIFT) |
+        (BigInt(routeId) << ROUTE_ID_SHIFT) |
+        (BigInt(tripIndex) << TRIP_INDEX_SHIFT));
+};
+/**
+ * Decodes a trip boarding ID back into its constituent stop index, route ID, and trip index.
+ * @param tripBoardingId - The encoded trip ID
+ * @returns A tuple containing [stopIndex, routeId, tripIndex]
+ */
+const decode = (tripBoardingId) => {
+    const stopIndex = Number((tripBoardingId >> STOP_INDEX_SHIFT) & VALUE_MASK);
+    const routeId = Number((tripBoardingId >> ROUTE_ID_SHIFT) & VALUE_MASK);
+    const tripIndex = Number((tripBoardingId >> TRIP_INDEX_SHIFT) & VALUE_MASK);
+    return [stopIndex, routeId, tripIndex];
+};
+
 const isLittleEndian = (() => {
     const buffer = new ArrayBuffer(4);
     const view = new DataView(buffer);
@@ -13118,9 +13434,15 @@ const bytesToUint16Array = (bytes) => {
 const serializeStopsAdjacency = (stopsAdjacency) => {
     return stopsAdjacency.map((value) => {
         return {
-            transfers: value.transfers.map((transfer) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
-                minTransferTime: transfer.minTransferTime.toSeconds(),
-            })))),
+            transfers: value.transfers
+                ? value.transfers.map((transfer) => ({
+                    destination: transfer.destination,
+                    type: serializeTransferType(transfer.type),
+                    ...(transfer.minTransferTime !== undefined && {
+                        minTransferTime: transfer.minTransferTime.toSeconds(),
+                    }),
+                }))
+                : [],
             routes: value.routes,
         };
     });
@@ -13156,15 +13478,22 @@ const deserializeStopsAdjacency = (protoStopsAdjacency) => {
         for (let j = 0; j < value.transfers.length; j++) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const transfer = value.transfers[j];
-            const newTransfer = Object.assign({ destination: transfer.destination, type: parseTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
-                minTransferTime: Duration.fromSeconds(transfer.minTransferTime),
-            }));
+            const newTransfer = {
+                destination: transfer.destination,
+                type: parseTransferType(transfer.type),
+                ...(transfer.minTransferTime !== undefined && {
+                    minTransferTime: Duration.fromSeconds(transfer.minTransferTime),
+                }),
+            };
             transfers.push(newTransfer);
         }
-        result.push({
-            transfers: transfers,
+        const stopAdjacency = {
             routes: value.routes,
-        });
+        };
+        if (transfers.length > 0) {
+            stopAdjacency.transfers = transfers;
+        }
+        result.push(stopAdjacency);
     }
     return result;
 };
@@ -13174,7 +13503,7 @@ const deserializeRoutesAdjacency = (protoRoutesAdjacency) => {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const value = protoRoutesAdjacency[i];
         const stops = bytesToUint32Array(value.stops);
-        routesAdjacency.push(new Route(bytesToUint16Array(value.stopTimes), value.pickUpDropOffTypes, stops, value.serviceRouteId));
+        routesAdjacency.push(new Route(i, bytesToUint16Array(value.stopTimes), value.pickUpDropOffTypes, stops, value.serviceRouteId));
     }
     return routesAdjacency;
 };
@@ -13268,6 +13597,38 @@ const serializeRouteType = (type) => {
             return RouteType.MONORAIL;
     }
 };
+const serializeTripContinuations = (tripContinuations) => {
+    const result = [];
+    for (const [tripBoardingId, boardings] of tripContinuations.entries()) {
+        const [originStopIndex, originRouteId, originTripIndex] = decode(tripBoardingId);
+        result.push({
+            originStopIndex,
+            originRouteId,
+            originTripIndex,
+            continuations: boardings.map((tripBoarding) => ({
+                hopOnStopIndex: tripBoarding.hopOnStopIndex,
+                routeId: tripBoarding.routeId,
+                tripIndex: tripBoarding.tripIndex,
+            })),
+        });
+    }
+    return result;
+};
+const deserializeTripContinuations = (protoTripContinuations) => {
+    const result = new Map();
+    for (let i = 0; i < protoTripContinuations.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const entry = protoTripContinuations[i];
+        const tripBoardingId = encode(entry.originStopIndex, entry.originRouteId, entry.originTripIndex);
+        const tripBoardings = entry.continuations.map((protoTripBoarding) => ({
+            hopOnStopIndex: protoTripBoarding.hopOnStopIndex,
+            routeId: protoTripBoarding.routeId,
+            tripIndex: protoTripBoarding.tripIndex,
+        }));
+        result.set(tripBoardingId, tripBoardings);
+    }
+    return result;
+};
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 const ALL_TRANSPORT_MODES = new Set([
@@ -13282,20 +13643,27 @@ const ALL_TRANSPORT_MODES = new Set([
     'TROLLEYBUS',
     'MONORAIL',
 ]);
-const CURRENT_VERSION = '0.0.7';
+const EMPTY_TRIP_CONTINUATIONS = [];
+const CURRENT_VERSION = '0.0.9';
 /**
  * The internal transit timetable format.
  */
 class Timetable {
-    constructor(stopsAdjacency, routesAdjacency, routes) {
+    stopsAdjacency;
+    routesAdjacency;
+    serviceRoutes;
+    tripContinuations;
+    activeStops;
+    constructor(stopsAdjacency, routesAdjacency, routes, tripContinuations) {
         this.stopsAdjacency = stopsAdjacency;
         this.routesAdjacency = routesAdjacency;
         this.serviceRoutes = routes;
+        this.tripContinuations = tripContinuations;
         this.activeStops = new Set();
         for (let i = 0; i < stopsAdjacency.length; i++) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const stop = stopsAdjacency[i];
-            if (stop.routes.length > 0 || stop.transfers.length > 0) {
+            if (stop.routes.length > 0 ||
+                (stop.transfers && stop.transfers.length > 0)) {
                 this.activeStops.add(i);
             }
         }
@@ -13311,6 +13679,7 @@ class Timetable {
             stopsAdjacency: serializeStopsAdjacency(this.stopsAdjacency),
             routesAdjacency: serializeRoutesAdjacency(this.routesAdjacency),
             serviceRoutes: serializeServiceRoutesMap(this.serviceRoutes),
+            tripContinuations: serializeTripContinuations(this.tripContinuations || new Map()),
         };
         const writer = new BinaryWriter();
         Timetable$1.encode(protoTimetable, writer);
@@ -13328,7 +13697,7 @@ class Timetable {
         if (protoTimetable.version !== CURRENT_VERSION) {
             throw new Error(`Unsupported timetable version ${protoTimetable.version}`);
         }
-        return new Timetable(deserializeStopsAdjacency(protoTimetable.stopsAdjacency), deserializeRoutesAdjacency(protoTimetable.routesAdjacency), deserializeServiceRoutesMap(protoTimetable.serviceRoutes));
+        return new Timetable(deserializeStopsAdjacency(protoTimetable.stopsAdjacency), deserializeRoutesAdjacency(protoTimetable.routesAdjacency), deserializeServiceRoutesMap(protoTimetable.serviceRoutes), deserializeTripContinuations(protoTimetable.tripContinuations));
     }
     /**
      * Checks if the given stop is active on the timetable.
@@ -13358,8 +13727,26 @@ class Timetable {
      * @returns An array of transfer options available at the stop.
      */
     getTransfers(stopId) {
-        var _a, _b;
-        return (_b = (_a = this.stopsAdjacency[stopId]) === null || _a === void 0 ? void 0 : _a.transfers) !== null && _b !== void 0 ? _b : [];
+        const stopAdjacency = this.stopsAdjacency[stopId];
+        if (!stopAdjacency) {
+            throw new Error(`Stop ID ${stopId} not found`);
+        }
+        return stopAdjacency.transfers || [];
+    }
+    /**
+     * Retrieves all trip continuation options available at the specified stop for a given trip.
+     *
+     * @param stopIndex - The index in the route of the stop to get trip continuations for.
+     * @param routeId - The ID of the route to get continuations for.
+     * @param tripIndex - The index of the trip to get continuations for.
+     * @returns An array of trip continuation options available at the stop for the specified trip.
+     */
+    getContinuousTrips(stopIndex, routeId, tripIndex) {
+        const tripContinuations = this.tripContinuations?.get(encode(stopIndex, routeId, tripIndex));
+        if (!tripContinuations) {
+            return EMPTY_TRIP_CONTINUATIONS;
+        }
+        return tripContinuations;
     }
     /**
      * Retrieves the service route associated with the given route.
@@ -13399,12 +13786,12 @@ class Timetable {
     }
     /**
      * Finds routes that are reachable from a set of stop IDs.
-     * Also identifies the first stop available to hop on each route among
+     * Also identifies the first stop index available to hop on each route among
      * the input stops.
      *
      * @param fromStops - The set of stop IDs to find reachable routes from.
      * @param transportModes - The set of transport modes to consider for reachable routes.
-     * @returns A map of reachable routes to the first stop available to hop on each route.
+     * @returns A map of reachable routes to the first stop index available to hop on each route.
      */
     findReachableRoutes(fromStops, transportModes = ALL_TRANSPORT_MODES) {
         const reachableRoutes = new Map();
@@ -13417,15 +13804,17 @@ class Timetable {
             });
             for (let j = 0; j < validRoutes.length; j++) {
                 const route = validRoutes[j];
-                const hopOnStop = reachableRoutes.get(route);
-                if (hopOnStop) {
-                    if (route.isBefore(originStop, hopOnStop)) {
+                const originStopIndices = route.stopRouteIndices(originStop);
+                const originStopIndex = originStopIndices[0];
+                const existingHopOnStopIndex = reachableRoutes.get(route);
+                if (existingHopOnStopIndex !== undefined) {
+                    if (originStopIndex < existingHopOnStopIndex) {
                         // if the current stop is before the existing hop on stop, replace it
-                        reachableRoutes.set(route, originStop);
+                        reachableRoutes.set(route, originStopIndex);
                     }
                 }
                 else {
-                    reachableRoutes.set(route, originStop);
+                    reachableRoutes.set(route, originStopIndex);
                 }
             }
         }
@@ -15401,35 +15790,22 @@ const parseCsv = (stream, numericColumns = []) => {
  * @param profile A configuration object defining the specificities of the GTFS feed.
  * @returns A map of all the valid routes.
  */
-const parseRoutes = (routesStream_1, ...args_1) => __awaiter(void 0, [routesStream_1, ...args_1], void 0, function* (routesStream, profile = standardProfile) {
-    var _a, e_1, _b, _c;
+const parseRoutes = async (routesStream, profile = standardProfile) => {
     const routes = new Map();
-    try {
-        for (var _d = true, _e = __asyncValues(parseCsv(routesStream, ['route_type'])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-            _c = _f.value;
-            _d = false;
-            const rawLine = _c;
-            const line = rawLine;
-            const routeType = profile.routeTypeParser(line.route_type);
-            if (routeType === undefined) {
-                log.info(`Unsupported route type ${line.route_type} for route ${line.route_id}.`);
-                continue;
-            }
-            routes.set(line.route_id, {
-                name: line.route_short_name,
-                type: routeType,
-            });
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+    for await (const rawLine of parseCsv(routesStream, ['route_type'])) {
+        const line = rawLine;
+        const routeType = profile.routeTypeParser(line.route_type);
+        if (routeType === undefined) {
+            log.info(`Unsupported route type ${line.route_type} for route ${line.route_id}.`);
+            continue;
         }
-        finally { if (e_1) throw e_1.error; }
+        routes.set(line.route_id, {
+            name: line.route_short_name,
+            type: routeType,
+        });
     }
     return routes;
-});
+};
 /**
  * Creates an array of ServiceRoute objects by combining GTFS route data with service route mappings.
  *
@@ -15492,46 +15868,33 @@ const weekdays = {
  * @param date The active date.
  * @param calendarStream A readable stream for the GTFS calendar.txt file.
  */
-const parseCalendar = (calendarStream, serviceIds, date) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_1, _b, _c;
+const parseCalendar = async (calendarStream, serviceIds, date) => {
     const activeDate = toGtfsDate(date);
     const weekday = date.weekday;
     const weekdayIndex = weekdays[weekday];
-    try {
-        for (var _d = true, _e = __asyncValues(parseCsv(calendarStream, [
-            'monday',
-            'tuesday',
-            'wednesday',
-            'thursday',
-            'friday',
-            'saturday',
-            'sunday',
-            'start_date',
-            'end_date',
-        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-            _c = _f.value;
-            _d = false;
-            const rawLine = _c;
-            const line = rawLine;
-            if (activeDate < line.start_date || activeDate > line.end_date) {
-                // If the service is not valid on this date
-                continue;
-            }
-            if (line[weekdayIndex] !== 1) {
-                // If the service is not valid on this week day
-                continue;
-            }
-            serviceIds.add(line['service_id']);
+    for await (const rawLine of parseCsv(calendarStream, [
+        'monday',
+        'tuesday',
+        'wednesday',
+        'thursday',
+        'friday',
+        'saturday',
+        'sunday',
+        'start_date',
+        'end_date',
+    ])) {
+        const line = rawLine;
+        if (activeDate < line.start_date || activeDate > line.end_date) {
+            // If the service is not valid on this date
+            continue;
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        if (line[weekdayIndex] !== 1) {
+            // If the service is not valid on this week day
+            continue;
         }
-        finally { if (e_1) throw e_1.error; }
+        serviceIds.add(line['service_id']);
     }
-});
+};
 /**
  * Parses a gtfs calendar_dates.txt file and finds the service ids valid at a given date.
  *
@@ -15539,39 +15902,24 @@ const parseCalendar = (calendarStream, serviceIds, date) => __awaiter(void 0, vo
  * @param date The active date, in the format "YYYYMMDD".
  * @param calendarDatesStream A readable stream for the GTFS calendar_dates.txt file.
  */
-const parseCalendarDates = (calendarDatesStream, serviceIds, date) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_2, _b, _c;
+const parseCalendarDates = async (calendarDatesStream, serviceIds, date) => {
     const activeDate = toGtfsDate(date);
-    try {
-        for (var _d = true, _e = __asyncValues(parseCsv(calendarDatesStream, [
-            'date',
-            'exception_type',
-        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-            _c = _f.value;
-            _d = false;
-            const rawLine = _c;
-            const line = rawLine;
-            if (line.date !== activeDate) {
-                // No rule on the active date
-            }
-            else if (line.exception_type === 2 && serviceIds.has(line.service_id)) {
-                // Service has been removed for the specified date.
-                serviceIds.delete(line.service_id);
-            }
-            else if (line.exception_type === 1) {
-                // Service is present on the active date
-                serviceIds.add(line.service_id);
-            }
+    for await (const rawLine of parseCsv(calendarDatesStream, [
+        'date',
+        'exception_type',
+    ])) {
+        const line = rawLine;
+        if (line.date !== activeDate) ;
+        else if (line.exception_type === 2 && serviceIds.has(line.service_id)) {
+            // Service has been removed for the specified date.
+            serviceIds.delete(line.service_id);
         }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        else if (line.exception_type === 1) {
+            // Service is present on the active date
+            serviceIds.add(line.service_id);
         }
-        finally { if (e_2) throw e_2.error; }
     }
-});
+};
 
 /**
  * Parses the stops.txt file from a GTFS feed.
@@ -15579,33 +15927,30 @@ const parseCalendarDates = (calendarDatesStream, serviceIds, date) => __awaiter(
  * @param stopsStream The readable stream containing the stops data.
  * @return A mapping of stop IDs to corresponding stop details.
  */
-const parseStops = (stopsStream) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_1, _b, _c;
+const parseStops = async (stopsStream) => {
     const parsedStops = new Map();
     let i = 0;
-    try {
-        for (var _d = true, _e = __asyncValues(parseCsv(stopsStream, [
-            'stop_lat',
-            'stop_lon',
-            'location_type',
-        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-            _c = _f.value;
-            _d = false;
-            const rawLine = _c;
-            const line = rawLine;
-            const stop = Object.assign(Object.assign(Object.assign({ id: i, sourceStopId: line.stop_id, name: line.stop_name, lat: line.stop_lat, lon: line.stop_lon, locationType: line.location_type
-                    ? parseGtfsLocationType(line.location_type)
-                    : 'SIMPLE_STOP_OR_PLATFORM' }, (line.platform_code && { platform: line.platform_code })), { children: [] }), (line.parent_station && { parentSourceId: line.parent_station }));
-            parsedStops.set(line.stop_id, stop);
-            i = i + 1;
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-        }
-        finally { if (e_1) throw e_1.error; }
+    for await (const rawLine of parseCsv(stopsStream, [
+        'stop_lat',
+        'stop_lon',
+        'location_type',
+    ])) {
+        const line = rawLine;
+        const stop = {
+            id: i,
+            sourceStopId: line.stop_id,
+            name: line.stop_name,
+            lat: line.stop_lat,
+            lon: line.stop_lon,
+            locationType: line.location_type
+                ? parseGtfsLocationType(line.location_type)
+                : 'SIMPLE_STOP_OR_PLATFORM',
+            ...(line.platform_code && { platform: line.platform_code }),
+            children: [],
+            ...(line.parent_station && { parentSourceId: line.parent_station }),
+        };
+        parsedStops.set(line.stop_id, stop);
+        i = i + 1;
     }
     for (const [sourceStopId, stop] of parsedStops) {
         if (stop.parentSourceId) {
@@ -15619,7 +15964,7 @@ const parseStops = (stopsStream) => __awaiter(void 0, void 0, void 0, function*
         }
     }
     return parsedStops;
-});
+};
 const parseGtfsLocationType = (gtfsLocationType) => {
     switch (gtfsLocationType) {
         case 0:
@@ -15642,58 +15987,158 @@ const parseGtfsLocationType = (gtfsLocationType) => {
  * @param stopsStream The readable stream containing the stops data.
  * @return A mapping of stop IDs to corresponding stop details.
  */
-const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_1, _b, _c;
+const parseTransfers = async (transfersStream, stopsMap) => {
     const transfers = new Map();
-    try {
-        for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
-            'transfer_type',
-            'min_transfer_time',
-        ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-            _c = _f.value;
-            _d = false;
-            const rawLine = _c;
-            const transferEntry = rawLine;
-            if (transferEntry.transfer_type === 3 ||
-                transferEntry.transfer_type === 5) {
-                continue;
-            }
-            if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
-                console.warn(`Unsupported transfer between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`);
-                continue;
-            }
-            if (transferEntry.from_route_id && transferEntry.to_route_id) {
-                console.warn(`Unsupported transfer between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`);
-                continue;
-            }
-            if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
-                console.warn(`Missing transfer origin or destination stop.`);
+    const tripContinuations = [];
+    for await (const rawLine of parseCsv(transfersStream, [
+        'transfer_type',
+        'min_transfer_time',
+    ])) {
+        const transferEntry = rawLine;
+        if (transferEntry.transfer_type === 3 ||
+            transferEntry.transfer_type === 5) {
+            continue;
+        }
+        if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
+            console.warn(`Missing transfer origin or destination stop.`);
+            continue;
+        }
+        const fromStop = stopsMap.get(transferEntry.from_stop_id);
+        const toStop = stopsMap.get(transferEntry.to_stop_id);
+        if (!fromStop || !toStop) {
+            console.warn(`Transfer references non-existent stop(s): from_stop_id=${transferEntry.from_stop_id}, to_stop_id=${transferEntry.to_stop_id}`);
+            continue;
+        }
+        if (transferEntry.transfer_type === 4) {
+            if (transferEntry.from_trip_id === undefined ||
+                transferEntry.from_trip_id === '' ||
+                transferEntry.to_trip_id === undefined ||
+                transferEntry.to_trip_id === '') {
+                console.warn(`Unsupported in-seat transfer, missing from_trip_id and/or to_trip_id.`);
                 continue;
             }
-            if (transferEntry.transfer_type === 2 && !transferEntry.min_transfer_time) {
-                console.info(`Missing minimum transfer time between ${transferEntry.from_stop_id} and ${transferEntry.to_stop_id}.`);
-            }
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const fromStop = stopsMap.get(transferEntry.from_stop_id);
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const toStop = stopsMap.get(transferEntry.to_stop_id);
-            const transfer = Object.assign({ destination: toStop.id, type: parseGtfsTransferType(transferEntry.transfer_type) }, (transferEntry.min_transfer_time && {
+            const tripBoardingEntry = {
+                fromStop: fromStop.id,
+                fromTrip: transferEntry.from_trip_id,
+                toStop: toStop.id,
+                toTrip: transferEntry.to_trip_id,
+            };
+            tripContinuations.push(tripBoardingEntry);
+            continue;
+        }
+        if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
+            console.warn(`Unsupported transfer of type ${transferEntry.transfer_type} between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`);
+            continue;
+        }
+        if (transferEntry.from_route_id && transferEntry.to_route_id) {
+            console.warn(`Unsupported transfer of type ${transferEntry.transfer_type} between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`);
+            continue;
+        }
+        if (transferEntry.transfer_type === 2 &&
+            transferEntry.min_transfer_time === undefined) {
+            console.info(`Missing minimum transfer time between ${transferEntry.from_stop_id} and ${transferEntry.to_stop_id}.`);
+        }
+        const transfer = {
+            destination: toStop.id,
+            type: parseGtfsTransferType(transferEntry.transfer_type),
+            ...(transferEntry.min_transfer_time !== undefined && {
                 minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
-            }));
-            const fromStopTransfers = transfers.get(fromStop.id) || [];
-            fromStopTransfers.push(transfer);
-            transfers.set(fromStop.id, fromStopTransfers);
+            }),
+        };
+        const fromStopTransfers = transfers.get(fromStop.id) || [];
+        fromStopTransfers.push(transfer);
+        transfers.set(fromStop.id, fromStopTransfers);
+    }
+    return {
+        transfers,
+        tripContinuations,
+    };
+};
+/**
+ * Disambiguates stops involved in a transfer.
+ *
+ * The GTFS specification only refers to a stopId in the trip-to-trip transfers and not the
+ * specific stop index in the route. For routes that have multiple stops with the same stopId,
+ * we need to determine which are the from / to stop indices in respective routes.
+ * We do so by picking the stop indices leading to the most coherent transfer.
+ * (we pick the closest from stop index happening after the to stop index).
+ */
+const disambiguateTransferStopsIndices = (fromStop, fromRoute, fromTripIndex, toStop, toRoute, toTripIndex) => {
+    const fromStopIndices = fromRoute.stopRouteIndices(fromStop);
+    const toStopIndices = toRoute.stopRouteIndices(toStop);
+    let bestFromStopIndex;
+    let bestToStopIndex;
+    let bestTimeDifference = Infinity;
+    for (const originStopIndex of fromStopIndices) {
+        const fromArrivalTime = fromRoute.arrivalAt(originStopIndex, fromTripIndex);
+        for (const toStopIndex of toStopIndices) {
+            const toDepartureTime = toRoute.departureFrom(toStopIndex, toTripIndex);
+            if (toDepartureTime.isAfter(fromArrivalTime)) {
+                const timeDifference = toDepartureTime.toMinutes() - fromArrivalTime.toMinutes();
+                if (timeDifference < bestTimeDifference) {
+                    bestTimeDifference = timeDifference;
+                    bestFromStopIndex = originStopIndex;
+                    bestToStopIndex = toStopIndex;
+                }
+            }
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+    if (bestFromStopIndex !== undefined && bestToStopIndex !== undefined) {
+        return {
+            fromStopIndex: bestFromStopIndex,
+            toStopIndex: bestToStopIndex,
+        };
+    }
+    return undefined;
+};
+/**
+ * Builds trip continuations map from GTFS trip continuation data.
+ *
+ * This function processes GTFS in-seat transfer data and creates a mapping
+ * from trip boarding IDs to continuation boarding information. It disambiguates
+ * stop indices when routes have multiple stops with the same ID by finding
+ * the most coherent transfer timing.
+ *
+ * @param tripsMapping Mapping from GTFS trip IDs to internal trip representations
+ * @param tripContinuations Array of GTFS trip continuation data from transfers.txt
+ * @param timetable The timetable containing route and timing information
+ * @param activeStopIds Set of stop IDs that are active/enabled in the system
+ * @returns A map from trip boarding IDs to arrays of continuation boarding options
+ */
+const buildTripContinuations = (tripsMapping, tripContinuations, timetable, activeStopIds) => {
+    const continuations = new Map();
+    for (const gtfsContinuation of tripContinuations) {
+        if (!activeStopIds.has(gtfsContinuation.fromStop) ||
+            !activeStopIds.has(gtfsContinuation.toStop)) {
+            continue;
         }
-        finally { if (e_1) throw e_1.error; }
+        const fromTripMapping = tripsMapping.get(gtfsContinuation.fromTrip);
+        const toTripMapping = tripsMapping.get(gtfsContinuation.toTrip);
+        if (!fromTripMapping || !toTripMapping) {
+            continue;
+        }
+        const fromRoute = timetable.getRoute(fromTripMapping.routeId);
+        const toRoute = timetable.getRoute(toTripMapping.routeId);
+        if (!fromRoute || !toRoute) {
+            continue;
+        }
+        const bestStopIndices = disambiguateTransferStopsIndices(gtfsContinuation.fromStop, fromRoute, fromTripMapping.tripRouteIndex, gtfsContinuation.toStop, toRoute, toTripMapping.tripRouteIndex);
+        if (!bestStopIndices) {
+            // No valid continuation found
+            continue;
+        }
+        const tripBoardingId = encode(bestStopIndices.fromStopIndex, fromTripMapping.routeId, fromTripMapping.tripRouteIndex);
+        const continuationBoarding = {
+            hopOnStopIndex: bestStopIndices.toStopIndex,
+            routeId: toTripMapping.routeId,
+            tripIndex: toTripMapping.tripRouteIndex,
+        };
+        const existingContinuations = continuations.get(tripBoardingId) || [];
+        existingContinuations.push(continuationBoarding);
+        continuations.set(tripBoardingId, existingContinuations);
     }
-    return transfers;
-});
+    return continuations;
+};
 const parseGtfsTransferType = (gtfsTransferType) => {
     switch (gtfsTransferType) {
         case 0:
@@ -15755,11 +16200,13 @@ const finalizeRouteFromBuilder = (builder) => {
     const stopTimesArray = new Uint16Array(stopsCount * tripsCount * 2);
     const allPickUpTypes = [];
     const allDropOffTypes = [];
+    const gtfsTripIds = [];
     for (let tripIndex = 0; tripIndex < tripsCount; tripIndex++) {
         const trip = builder.trips[tripIndex];
         if (!trip) {
             throw new Error(`Missing trip data at index ${tripIndex}`);
         }
+        gtfsTripIds.push(trip.gtfsTripId);
         const baseIndex = tripIndex * stopsCount * 2;
         for (let stopIndex = 0; stopIndex < stopsCount; stopIndex++) {
             const timeIndex = baseIndex + stopIndex * 2;
@@ -15781,12 +16228,15 @@ const finalizeRouteFromBuilder = (builder) => {
     }
     // Use 2-bit encoding for pickup/drop-off types
     const pickUpDropOffTypesArray = encodePickUpDropOffTypes(allPickUpTypes, allDropOffTypes);
-    return {
-        serviceRouteId: builder.serviceRouteId,
-        stops: stopsArray,
-        stopTimes: stopTimesArray,
-        pickUpDropOffTypes: pickUpDropOffTypesArray,
-    };
+    return [
+        {
+            serviceRouteId: builder.serviceRouteId,
+            stops: stopsArray,
+            stopTimes: stopTimesArray,
+            pickUpDropOffTypes: pickUpDropOffTypesArray,
+        },
+        gtfsTripIds,
+    ];
 };
 /**
  * Parses the trips.txt file from a GTFS feed
@@ -15796,40 +16246,28 @@ const finalizeRouteFromBuilder = (builder) => {
  * @param serviceRoutes A mapping of route IDs to route details.
  * @returns A mapping of trip IDs to corresponding route IDs.
  */
-const parseTrips = (tripsStream, serviceIds, validGtfsRoutes) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_1, _b, _c;
+const parseTrips = async (tripsStream, serviceIds, validGtfsRoutes) => {
     const trips = new Map();
-    try {
-        for (var _d = true, _e = __asyncValues(parseCsv(tripsStream, ['stop_sequence'])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-            _c = _f.value;
-            _d = false;
-            const rawLine = _c;
-            const line = rawLine;
-            if (!serviceIds.has(line.service_id)) {
-                // The trip doesn't correspond to an active service
-                continue;
-            }
-            if (!validGtfsRoutes.has(line.route_id)) {
-                // The trip doesn't correspond to a supported route
-                continue;
-            }
-            trips.set(line.trip_id, line.route_id);
+    for await (const rawLine of parseCsv(tripsStream, ['stop_sequence'])) {
+        const line = rawLine;
+        if (!serviceIds.has(line.service_id)) {
+            // The trip doesn't correspond to an active service
+            continue;
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        if (!validGtfsRoutes.has(line.route_id)) {
+            // The trip doesn't correspond to a supported route
+            continue;
         }
-        finally { if (e_1) throw e_1.error; }
+        trips.set(line.trip_id, line.route_id);
     }
     return trips;
-});
+};
 const buildStopsAdjacencyStructure = (serviceRoutes, routes, transfersMap, nbStops, activeStops) => {
-    // TODO somehow works when it's a map
     const stopsAdjacency = new Array(nbStops);
     for (let i = 0; i < nbStops; i++) {
-        stopsAdjacency[i] = { routes: [], transfers: [] };
+        stopsAdjacency[i] = {
+            routes: [],
+        };
     }
     for (let index = 0; index < routes.length; index++) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -15854,7 +16292,11 @@ const buildStopsAdjacencyStructure = (serviceRoutes, routes, transfersMap, nbSto
             const transfer = transfers[i];
             if (activeStops.has(stop) || activeStops.has(transfer.destination)) {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                stopsAdjacency[stop].transfers.push(transfer);
+                const stopAdj = stopsAdjacency[stop];
+                if (!stopAdj.transfers) {
+                    stopAdj.transfers = [];
+                }
+                stopAdj.transfers.push(transfer);
                 activeStops.add(transfer.destination);
                 activeStops.add(stop);
             }
@@ -15871,9 +16313,7 @@ const buildStopsAdjacencyStructure = (serviceRoutes, routes, transfersMap, nbSto
  * @param activeStopIds A set of valid stop IDs.
  * @returns A mapping of route IDs to route details. The routes returned correspond to the set of trips from GTFS that share the same stop list.
  */
-const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_2, _b, _c;
-    var _d, _e;
+const parseStopTimes = async (stopTimesStream, stopsMap, activeTripIds, activeStopIds) => {
     /**
      * Adds a trip to the appropriate route builder
      */
@@ -15918,6 +16358,7 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
         }
         routeBuilder.trips.push({
             firstDeparture,
+            gtfsTripId: currentTripId,
             arrivalTimes: arrivalTimes,
             departureTimes: departureTimes,
             pickUpTypes: pickUpTypes,
@@ -15940,63 +16381,62 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
     let pickUpTypes = [];
     let dropOffTypes = [];
     let currentTripId = undefined;
-    try {
-        for (var _f = true, _g = __asyncValues(parseCsv(stopTimesStream, ['stop_sequence'])), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
-            _c = _h.value;
-            _f = false;
-            const rawLine = _c;
-            const line = rawLine;
-            if (line.trip_id === currentTripId && line.stop_sequence <= previousSeq) {
-                console.warn(`Stop sequences not increasing for trip ${line.trip_id}: ${line.stop_sequence} > ${previousSeq}.`);
-                continue;
-            }
-            if (!line.arrival_time && !line.departure_time) {
-                console.warn(`Missing arrival or departure time for ${line.trip_id} at stop ${line.stop_id}.`);
-                continue;
-            }
-            if (line.pickup_type === '1' && line.drop_off_type === '1') {
-                continue;
-            }
-            if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
-                addTrip(currentTripId);
-            }
-            currentTripId = line.trip_id;
-            const stopData = stopsMap.get(line.stop_id);
-            if (!stopData) {
-                console.warn(`Unknown stop ID: ${line.stop_id}`);
-                continue;
-            }
-            stops.push(stopData.id);
-            const departure = (_d = line.departure_time) !== null && _d !== void 0 ? _d : line.arrival_time;
-            const arrival = (_e = line.arrival_time) !== null && _e !== void 0 ? _e : line.departure_time;
-            if (!arrival || !departure) {
-                console.warn(`Missing time data for ${line.trip_id} at stop ${line.stop_id}`);
-                continue;
-            }
-            arrivalTimes.push(toTime(arrival).toMinutes());
-            departureTimes.push(toTime(departure).toMinutes());
-            pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
-            dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
-            previousSeq = line.stop_sequence;
+    for await (const rawLine of parseCsv(stopTimesStream, ['stop_sequence'])) {
+        const line = rawLine;
+        if (line.trip_id === currentTripId && line.stop_sequence <= previousSeq) {
+            console.warn(`Stop sequences not increasing for trip ${line.trip_id}: ${line.stop_sequence} > ${previousSeq}.`);
+            continue;
         }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+        if (!line.arrival_time && !line.departure_time) {
+            console.warn(`Missing arrival or departure time for ${line.trip_id} at stop ${line.stop_id}.`);
+            continue;
+        }
+        if (line.pickup_type === '1' && line.drop_off_type === '1') {
+            // Warning: could potentially lead to issues if there is an in-seat transfer
+            // at this stop - it can be not boardable nor alightable but still useful for an in-seat transfer.
+            // This doesn't seem to happen in practice for now so keeping this condition to save memory.
+            continue;
+        }
+        if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
+            addTrip(currentTripId);
+        }
+        currentTripId = line.trip_id;
+        const stopData = stopsMap.get(line.stop_id);
+        if (!stopData) {
+            console.warn(`Unknown stop ID: ${line.stop_id}`);
+            continue;
+        }
+        stops.push(stopData.id);
+        const departure = line.departure_time ?? line.arrival_time;
+        const arrival = line.arrival_time ?? line.departure_time;
+        if (!arrival || !departure) {
+            console.warn(`Missing time data for ${line.trip_id} at stop ${line.stop_id}`);
+            continue;
         }
-        finally { if (e_2) throw e_2.error; }
+        arrivalTimes.push(toTime(arrival).toMinutes());
+        departureTimes.push(toTime(departure).toMinutes());
+        pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
+        dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
+        previousSeq = line.stop_sequence;
     }
     if (currentTripId) {
         addTrip(currentTripId);
     }
     const routesAdjacency = [];
+    const tripsMapping = new Map();
     for (const [, routeBuilder] of routeBuilders) {
-        const routeData = finalizeRouteFromBuilder(routeBuilder);
-        routesAdjacency.push(new Route(routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
+        const [routeData, gtfsTripIds] = finalizeRouteFromBuilder(routeBuilder);
+        const routeId = routesAdjacency.length;
+        routesAdjacency.push(new Route(routeId, routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
+        gtfsTripIds.forEach((tripId, index) => {
+            tripsMapping.set(tripId, {
+                routeId,
+                tripRouteIndex: index,
+            });
+        });
     }
-    return { routes: routesAdjacency, serviceRoutesMap };
-});
+    return { routes: routesAdjacency, serviceRoutesMap, tripsMapping };
+};
 const parsePickupDropOffType = (gtfsType) => {
     switch (gtfsType) {
         default:
@@ -16020,6 +16460,8 @@ const STOP_TIMES_FILE = 'stop_times.txt';
 const STOPS_FILE = 'stops.txt';
 const TRANSFERS_FILE = 'transfers.txt';
 class GtfsParser {
+    path;
+    profile;
     constructor(path, profile = standardProfile) {
         // TODO: support input from multiple sources
         this.path = path;
@@ -16031,74 +16473,81 @@ class GtfsParser {
      * @param date The active date.
      * @returns The parsed timetable.
      */
-    parseTimetable(date) {
-        return __awaiter(this, void 0, void 0, function* () {
-            log.setLevel('INFO');
-            const zip = new StreamZip.async({ file: this.path });
-            const entries = yield zip.entries();
-            const datetime = DateTime.fromJSDate(date);
-            const activeServiceIds = new Set();
-            const activeStopIds = new Set();
-            log.info(`Parsing ${STOPS_FILE}`);
-            const stopsStart = performance.now();
-            const stopsStream = yield zip.stream(STOPS_FILE);
-            const parsedStops = yield parseStops(stopsStream);
-            const stopsEnd = performance.now();
-            log.info(`${parsedStops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`);
-            if (entries[CALENDAR_FILE]) {
-                log.info(`Parsing ${CALENDAR_FILE}`);
-                const calendarStart = performance.now();
-                const calendarStream = yield zip.stream(CALENDAR_FILE);
-                yield parseCalendar(calendarStream, activeServiceIds, datetime);
-                const calendarEnd = performance.now();
-                log.info(`${activeServiceIds.size} valid services. (${(calendarEnd - calendarStart).toFixed(2)}ms)`);
-            }
-            if (entries[CALENDAR_DATES_FILE]) {
-                log.info(`Parsing ${CALENDAR_DATES_FILE}`);
-                const calendarDatesStart = performance.now();
-                const calendarDatesStream = yield zip.stream(CALENDAR_DATES_FILE);
-                yield parseCalendarDates(calendarDatesStream, activeServiceIds, datetime);
-                const calendarDatesEnd = performance.now();
-                log.info(`${activeServiceIds.size} valid services. (${(calendarDatesEnd - calendarDatesStart).toFixed(2)}ms)`);
-            }
-            log.info(`Parsing ${ROUTES_FILE}`);
-            const routesStart = performance.now();
-            const routesStream = yield zip.stream(ROUTES_FILE);
-            const validGtfsRoutes = yield parseRoutes(routesStream, this.profile);
-            const routesEnd = performance.now();
-            log.info(`${validGtfsRoutes.size} valid GTFS routes. (${(routesEnd - routesStart).toFixed(2)}ms)`);
-            log.info(`Parsing ${TRIPS_FILE}`);
-            const tripsStart = performance.now();
-            const tripsStream = yield zip.stream(TRIPS_FILE);
-            const trips = yield parseTrips(tripsStream, activeServiceIds, validGtfsRoutes);
-            const tripsEnd = performance.now();
-            log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
-            let transfers = new Map();
-            if (entries[TRANSFERS_FILE]) {
-                log.info(`Parsing ${TRANSFERS_FILE}`);
-                const transfersStart = performance.now();
-                const transfersStream = yield zip.stream(TRANSFERS_FILE);
-                transfers = yield parseTransfers(transfersStream, parsedStops);
-                const transfersEnd = performance.now();
-                log.info(`${transfers.size} valid transfers. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
-            }
-            log.info(`Parsing ${STOP_TIMES_FILE}`);
-            const stopTimesStart = performance.now();
-            const stopTimesStream = yield zip.stream(STOP_TIMES_FILE);
-            const { routes, serviceRoutesMap } = yield parseStopTimes(stopTimesStream, parsedStops, trips, activeStopIds);
-            const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
-            const stopTimesEnd = performance.now();
-            log.info(`${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
-            log.info('Building stops adjacency structure');
-            const stopsAdjacencyStart = performance.now();
-            const stopsAdjacency = buildStopsAdjacencyStructure(serviceRoutes, routes, transfers, parsedStops.size, activeStopIds);
-            const stopsAdjacencyEnd = performance.now();
-            log.info(`${stopsAdjacency.length} valid stops in the structure. (${(stopsAdjacencyEnd - stopsAdjacencyStart).toFixed(2)}ms)`);
-            yield zip.close();
-            const timetable = new Timetable(stopsAdjacency, routes, serviceRoutes);
-            log.info('Parsing complete.');
-            return timetable;
-        });
+    async parseTimetable(date) {
+        log.setLevel('INFO');
+        const zip = new StreamZip.async({ file: this.path });
+        const entries = await zip.entries();
+        const datetime = DateTime.fromJSDate(date);
+        const activeServiceIds = new Set();
+        const activeStopIds = new Set();
+        log.info(`Parsing ${STOPS_FILE}`);
+        const stopsStart = performance.now();
+        const stopsStream = await zip.stream(STOPS_FILE);
+        const parsedStops = await parseStops(stopsStream);
+        const stopsEnd = performance.now();
+        log.info(`${parsedStops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`);
+        if (entries[CALENDAR_FILE]) {
+            log.info(`Parsing ${CALENDAR_FILE}`);
+            const calendarStart = performance.now();
+            const calendarStream = await zip.stream(CALENDAR_FILE);
+            await parseCalendar(calendarStream, activeServiceIds, datetime);
+            const calendarEnd = performance.now();
+            log.info(`${activeServiceIds.size} valid services. (${(calendarEnd - calendarStart).toFixed(2)}ms)`);
+        }
+        if (entries[CALENDAR_DATES_FILE]) {
+            log.info(`Parsing ${CALENDAR_DATES_FILE}`);
+            const calendarDatesStart = performance.now();
+            const calendarDatesStream = await zip.stream(CALENDAR_DATES_FILE);
+            await parseCalendarDates(calendarDatesStream, activeServiceIds, datetime);
+            const calendarDatesEnd = performance.now();
+            log.info(`${activeServiceIds.size} valid services. (${(calendarDatesEnd - calendarDatesStart).toFixed(2)}ms)`);
+        }
+        log.info(`Parsing ${ROUTES_FILE}`);
+        const routesStart = performance.now();
+        const routesStream = await zip.stream(ROUTES_FILE);
+        const validGtfsRoutes = await parseRoutes(routesStream, this.profile);
+        const routesEnd = performance.now();
+        log.info(`${validGtfsRoutes.size} valid GTFS routes. (${(routesEnd - routesStart).toFixed(2)}ms)`);
+        log.info(`Parsing ${TRIPS_FILE}`);
+        const tripsStart = performance.now();
+        const tripsStream = await zip.stream(TRIPS_FILE);
+        const trips = await parseTrips(tripsStream, activeServiceIds, validGtfsRoutes);
+        const tripsEnd = performance.now();
+        log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
+        let transfers = new Map();
+        let tripContinuationsMap = [];
+        if (entries[TRANSFERS_FILE]) {
+            log.info(`Parsing ${TRANSFERS_FILE}`);
+            const transfersStart = performance.now();
+            const transfersStream = await zip.stream(TRANSFERS_FILE);
+            const { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, } = await parseTransfers(transfersStream, parsedStops);
+            transfers = parsedTransfers;
+            tripContinuationsMap = parsedTripContinuations;
+            const transfersEnd = performance.now();
+            log.info(`${transfers.size} valid transfers and ${tripContinuationsMap.length} trip continuations. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
+        }
+        log.info(`Parsing ${STOP_TIMES_FILE}`);
+        const stopTimesStart = performance.now();
+        const stopTimesStream = await zip.stream(STOP_TIMES_FILE);
+        const { routes, serviceRoutesMap, tripsMapping } = await parseStopTimes(stopTimesStream, parsedStops, trips, activeStopIds);
+        const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
+        const stopTimesEnd = performance.now();
+        log.info(`${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
+        log.info('Building stops adjacency structure');
+        const stopsAdjacencyStart = performance.now();
+        const stopsAdjacency = buildStopsAdjacencyStructure(serviceRoutes, routes, transfers, parsedStops.size, activeStopIds);
+        const stopsAdjacencyEnd = performance.now();
+        log.info(`${stopsAdjacency.length} valid stops in the structure. (${(stopsAdjacencyEnd - stopsAdjacencyStart).toFixed(2)}ms)`);
+        await zip.close();
+        // temporary timetable for building continuations
+        const timetable = new Timetable(stopsAdjacency, routes, serviceRoutes);
+        log.info('Building in-seat trip continuations');
+        const tripContinuationsStart = performance.now();
+        const tripContinuations = buildTripContinuations(tripsMapping, tripContinuationsMap, timetable, activeStopIds);
+        const tripContinuationsEnd = performance.now();
+        log.info(`${tripContinuations.size} in-seat trip continuations origins created. (${(tripContinuationsEnd - tripContinuationsStart).toFixed(2)}ms)`);
+        log.info('Parsing complete.');
+        return new Timetable(stopsAdjacency, routes, serviceRoutes, tripContinuations);
     }
     /**
      * Parses a GTFS feed to extract all stops.
@@ -16106,18 +16555,16 @@ class GtfsParser {
      * @param activeStops The set of active stop IDs to include in the index.
      * @returns An index of stops.
      */
-    parseStops() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const zip = new StreamZip.async({ file: this.path });
-            log.info(`Parsing ${STOPS_FILE}`);
-            const stopsStart = performance.now();
-            const stopsStream = yield zip.stream(STOPS_FILE);
-            const stops = yield parseStops(stopsStream);
-            const stopsEnd = performance.now();
-            log.info(`${stops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`);
-            yield zip.close();
-            return new StopsIndex(Array.from(stops.values()));
-        });
+    async parseStops() {
+        const zip = new StreamZip.async({ file: this.path });
+        log.info(`Parsing ${STOPS_FILE}`);
+        const stopsStart = performance.now();
+        const stopsStream = await zip.stream(STOPS_FILE);
+        const stops = await parseStops(stopsStream);
+        const stopsEnd = performance.now();
+        log.info(`${stops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`);
+        await zip.close();
+        return new StopsIndex(Array.from(stops.values()));
     }
 }