minotor 7.0.2 → 8.0.0

package/dist/parser.esm.js

@@ -12294,41 +12294,191 @@ const Transfer = {
         return message;
     },
 };
-function createBaseStopAdjacency() {
-    return { transfers: [], routes: [] };
+function createBaseTripBoarding() {
+    return { hopOnStop: 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.hopOnStop !== 0) {
+            writer.uint32(8).uint32(message.hopOnStop);
         }
-        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.hopOnStop = 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 {
+            hopOnStop: isSet(object.hopOnStop) ? globalThis.Number(object.hopOnStop) : 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.hopOnStop !== 0) {
+            obj.hopOnStop = Math.round(message.hopOnStop);
+        }
+        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 !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseTripBoarding();
+        message.hopOnStop = (_a = object.hopOnStop) !== null && _a !== void 0 ? _a : 0;
+        message.routeId = (_b = object.routeId) !== null && _b !== void 0 ? _b : 0;
+        message.tripIndex = (_c = object.tripIndex) !== null && _c !== void 0 ? _c : 0;
+        return message;
+    },
+};
+function createBaseTripContinuationEntry() {
+    return { key: 0, value: [] };
+}
+const TripContinuationEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== 0) {
+            writer.uint32(8).uint32(message.key);
+        }
+        for (const v of message.value) {
+            TripBoarding.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 = createBaseTripContinuationEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.key = reader.uint32();
                     continue;
                 }
                 case 2: {
-                    if (tag === 16) {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value.push(TripBoarding.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.Number(object.key) : 0,
+            value: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.value) ? object.value.map((e) => TripBoarding.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if (message.key !== 0) {
+            obj.key = Math.round(message.key);
+        }
+        if ((_a = message.value) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.value = message.value.map((e) => TripBoarding.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return TripContinuationEntry.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseTripContinuationEntry();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : 0;
+        message.value = ((_b = object.value) === null || _b === void 0 ? void 0 : _b.map((e) => TripBoarding.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBaseStopAdjacency() {
+    return { routes: [], transfers: [], tripContinuations: [] };
+}
+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();
+        }
+        for (const v of message.tripContinuations) {
+            TripContinuationEntry.encode(v, writer.uint32(26).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());
@@ -12337,6 +12487,20 @@ const StopAdjacency = {
                     }
                     break;
                 }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.transfers.push(Transfer.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.tripContinuations.push(TripContinuationEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -12347,20 +12511,26 @@ const StopAdjacency = {
     },
     fromJSON(object) {
         return {
+            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
             transfers: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.transfers)
                 ? object.transfers.map((e) => Transfer.fromJSON(e))
                 : [],
-            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
+            tripContinuations: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.tripContinuations)
+                ? object.tripContinuations.map((e) => TripContinuationEntry.fromJSON(e))
+                : [],
         };
     },
     toJSON(message) {
-        var _a, _b;
+        var _a, _b, _c;
         const obj = {};
-        if ((_a = message.transfers) === null || _a === void 0 ? void 0 : _a.length) {
+        if ((_a = message.routes) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.routes = message.routes.map((e) => Math.round(e));
+        }
+        if ((_b = message.transfers) === null || _b === void 0 ? void 0 : _b.length) {
             obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
         }
-        if ((_b = message.routes) === null || _b === void 0 ? void 0 : _b.length) {
-            obj.routes = message.routes.map((e) => Math.round(e));
+        if ((_c = message.tripContinuations) === null || _c === void 0 ? void 0 : _c.length) {
+            obj.tripContinuations = message.tripContinuations.map((e) => TripContinuationEntry.toJSON(e));
         }
         return obj;
     },
@@ -12368,10 +12538,11 @@ const StopAdjacency = {
         return StopAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b;
+        var _a, _b, _c;
         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 = ((_a = object.routes) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
+        message.transfers = ((_b = object.transfers) === null || _b === void 0 ? void 0 : _b.map((e) => Transfer.fromPartial(e))) || [];
+        message.tripContinuations = ((_c = object.tripContinuations) === null || _c === void 0 ? void 0 : _c.map((e) => TripContinuationEntry.fromPartial(e))) || [];
         return message;
     },
 };
@@ -12860,7 +13031,8 @@ 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) {
+    constructor(id, stopTimes, pickUpDropOffTypes, stops, serviceRouteId) {
+        this.id = id;
         this.stopTimes = stopTimes;
         this.pickUpDropOffTypes = pickUpDropOffTypes;
         this.stops = stops;
@@ -12873,6 +13045,78 @@ class Route {
             this.stopIndices.set(stops[i], 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) {
+        var _a, _b;
+        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 = (_a = stop.pickUpType) !== null && _a !== void 0 ? _a : REGULAR;
+                const dropOff = (_b = stop.dropOffType) !== null && _b !== void 0 ? _b : 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.
      *
@@ -12896,11 +13140,11 @@ class Route {
     isBefore(stopA, stopB) {
         const stopAIndex = this.stopIndices.get(stopA);
         if (stopAIndex === undefined) {
-            throw new Error(`Stop index ${stopAIndex} not found in route ${this.serviceRouteId}`);
+            throw new Error(`Stop index not found for ${stopA} 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}`);
+            throw new Error(`Stop index not found for ${stopB} in route ${this.serviceRouteId}`);
         }
         return stopAIndex < stopBIndex;
     }
@@ -12912,6 +13156,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.
@@ -12929,7 +13181,7 @@ class Route {
      * @returns The arrival time at the specified stop and trip as a Time object.
      */
     arrivalAt(stopId, tripIndex) {
-        const arrivalIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2;
+        const arrivalIndex = (tripIndex * this.stops.length + this.stopRouteIndex(stopId)) * 2;
         const arrival = this.stopTimes[arrivalIndex];
         if (arrival === undefined) {
             throw new Error(`Arrival time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
@@ -12944,7 +13196,7 @@ class Route {
      * @returns The departure time at the specified stop and trip as a Time object.
      */
     departureFrom(stopId, tripIndex) {
-        const departureIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2 + 1;
+        const departureIndex = (tripIndex * this.stops.length + this.stopRouteIndex(stopId)) * 2 + 1;
         const departure = this.stopTimes[departureIndex];
         if (departure === undefined) {
             throw new Error(`Departure time not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
@@ -12959,7 +13211,7 @@ class Route {
      * @returns The pick-up type at the specified stop and trip.
      */
     pickUpTypeFrom(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        const globalIndex = tripIndex * this.stops.length + this.stopRouteIndex(stopId);
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
@@ -12979,7 +13231,7 @@ class Route {
      * @returns The drop-off type at the specified stop and trip.
      */
     dropOffTypeAt(stopId, tripIndex) {
-        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        const globalIndex = tripIndex * this.stops.length + this.stopRouteIndex(stopId);
         const byteIndex = Math.floor(globalIndex / 2);
         const isSecondPair = globalIndex % 2 === 1;
         const byte = this.pickUpDropOffTypes[byteIndex];
@@ -13039,13 +13291,25 @@ class Route {
      * @param stopId The StopId of the stop to locate in the route.
      * @returns The index of the stop in the route.
      */
-    stopIndex(stopId) {
+    stopRouteIndex(stopId) {
         const stopIndex = this.stopIndices.get(stopId);
         if (stopIndex === undefined) {
             throw new Error(`Stop index for ${stopId} not found in route ${this.serviceRouteId}`);
         }
         return stopIndex;
     }
+    /**
+     * 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;
+    }
 }
 
 const isLittleEndian = (() => {
@@ -13116,10 +13380,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) => (Object.assign({ destination: transfer.destination, type: serializeTransferType(transfer.type) }, (transfer.minTransferTime !== undefined && {
+                    minTransferTime: transfer.minTransferTime.toSeconds(),
+                }))))
+                : [],
             routes: value.routes,
+            tripContinuations: value.tripContinuations
+                ? serializeTripContinuations(value.tripContinuations)
+                : [],
         };
     });
 };
@@ -13159,10 +13428,17 @@ const deserializeStopsAdjacency = (protoStopsAdjacency) => {
             }));
             transfers.push(newTransfer);
         }
-        result.push({
-            transfers: transfers,
+        const stopAdjacency = {
             routes: value.routes,
-        });
+        };
+        if (transfers.length > 0) {
+            stopAdjacency.transfers = transfers;
+        }
+        const deserializedTripContinuations = deserializeTripContinuations(value.tripContinuations);
+        if (deserializedTripContinuations.size > 0) {
+            stopAdjacency.tripContinuations = deserializedTripContinuations;
+        }
+        result.push(stopAdjacency);
     }
     return result;
 };
@@ -13172,7 +13448,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;
 };
@@ -13266,6 +13542,46 @@ const serializeRouteType = (type) => {
             return RouteType.MONORAIL;
     }
 };
+const serializeTripContinuations = (tripContinuations) => {
+    const result = [];
+    for (const [key, value] of tripContinuations.entries()) {
+        result.push({
+            key: key,
+            value: value.map((tripBoarding) => ({
+                hopOnStop: tripBoarding.hopOnStop,
+                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 tripBoardings = entry.value.map((protoTripBoarding) => ({
+            hopOnStop: protoTripBoarding.hopOnStop,
+            routeId: protoTripBoarding.routeId,
+            tripIndex: protoTripBoarding.tripIndex,
+        }));
+        result.set(entry.key, tripBoardings);
+    }
+    return result;
+};
+
+// const ROUTE_ID_BITS = 17;
+const TRIP_INDEX_BITS = 15;
+/**
+ * Encodes a route ID and trip index into a single trip ID.
+ * @param routeId - The route identifier, needs to fit on 17 bits
+ * @param tripIndex - The index of the trip within the route, needs to fit on 15 bits
+ * @returns The encoded trip ID
+ */
+const encode = (routeId, tripIndex) => {
+    return (routeId << TRIP_INDEX_BITS) | tripIndex;
+};
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 const ALL_TRANSPORT_MODES = new Set([
@@ -13280,7 +13596,8 @@ const ALL_TRANSPORT_MODES = new Set([
     'TROLLEYBUS',
     'MONORAIL',
 ]);
-const CURRENT_VERSION = '0.0.7';
+const EMPTY_TRIP_CONTINUATIONS = [];
+const CURRENT_VERSION = '0.0.8';
 /**
  * The internal transit timetable format.
  */
@@ -13291,9 +13608,10 @@ class Timetable {
         this.serviceRoutes = routes;
         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) ||
+                (stop.tripContinuations && stop.tripContinuations.size > 0)) {
                 this.activeStops.add(i);
             }
         }
@@ -13356,8 +13674,27 @@ 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 stopId - The ID of the stop to get trip 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(stopId, routeId, tripIndex) {
+        var _a;
+        const stopAdjacency = this.stopsAdjacency[stopId];
+        if (!stopAdjacency) {
+            throw new Error(`Stop ID ${stopId} not found`);
+        }
+        return (((_a = stopAdjacency.tripContinuations) === null || _a === void 0 ? void 0 : _a.get(encode(routeId, tripIndex))) ||
+            EMPTY_TRIP_CONTINUATIONS);
     }
     /**
      * Retrieves the service route associated with the given route.
@@ -15643,6 +15980,7 @@ const parseGtfsLocationType = (gtfsLocationType) => {
 const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
     const transfers = new Map();
+    const tripContinuations = new Map();
     try {
         for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
             'transfer_type',
@@ -15656,25 +15994,48 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
                 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.`);
                 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);
+            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;
+                }
+                const tripBoardingEntry = {
+                    fromTrip: transferEntry.from_trip_id,
+                    toTrip: transferEntry.to_trip_id,
+                    hopOnStop: toStop.id,
+                };
+                const existingBoardings = tripContinuations.get(fromStop.id);
+                if (existingBoardings) {
+                    existingBoardings.push(tripBoardingEntry);
+                }
+                else {
+                    tripContinuations.set(fromStop.id, [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 = Object.assign({ destination: toStop.id, type: parseGtfsTransferType(transferEntry.transfer_type) }, (transferEntry.min_transfer_time && {
                 minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
             }));
@@ -15690,7 +16051,10 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
         }
         finally { if (e_1) throw e_1.error; }
     }
-    return transfers;
+    return {
+        transfers,
+        tripContinuations,
+    };
 });
 const parseGtfsTransferType = (gtfsTransferType) => {
     switch (gtfsTransferType) {
@@ -15753,11 +16117,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;
@@ -15779,12 +16145,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
@@ -15823,11 +16192,12 @@ const parseTrips = (tripsStream, serviceIds, validGtfsRoutes) => __awaiter(void
     }
     return trips;
 });
-const buildStopsAdjacencyStructure = (serviceRoutes, routes, transfersMap, nbStops, activeStops) => {
-    // TODO somehow works when it's a map
+const buildStopsAdjacencyStructure = (tripsMapping, serviceRoutes, routes, transfersMap, tripContinuationsMap, nbStops, activeStops) => {
     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
@@ -15852,12 +16222,50 @@ 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);
             }
         }
     }
+    for (const [stop, tripContinuations] of tripContinuationsMap) {
+        for (let i = 0; i < tripContinuations.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const tripContinuation = tripContinuations[i];
+            if (activeStops.has(stop) ||
+                activeStops.has(tripContinuation.hopOnStop)) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const stopAdj = stopsAdjacency[stop];
+                if (!stopAdj.tripContinuations) {
+                    stopAdj.tripContinuations = new Map();
+                }
+                const originTrip = tripsMapping.get(tripContinuation.fromTrip);
+                const destinationTrip = tripsMapping.get(tripContinuation.toTrip);
+                if (destinationTrip === undefined || originTrip === undefined) {
+                    continue;
+                }
+                const tripBoarding = {
+                    hopOnStop: tripContinuation.hopOnStop,
+                    routeId: destinationTrip.routeId,
+                    tripIndex: destinationTrip.tripRouteIndex,
+                };
+                const tripId = encode(originTrip.routeId, originTrip.tripRouteIndex);
+                const existingContinuations = stopAdj.tripContinuations.get(tripId);
+                if (existingContinuations) {
+                    existingContinuations.push(tripBoarding);
+                }
+                else {
+                    stopAdj.tripContinuations.set(tripId, [tripBoarding]);
+                }
+                activeStops.add(tripContinuation.hopOnStop);
+                activeStops.add(stop);
+            }
+        }
+    }
     return stopsAdjacency;
 };
 /**
@@ -15916,6 +16324,7 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
         }
         routeBuilder.trips.push({
             firstDeparture,
+            gtfsTripId: currentTripId,
             arrivalTimes: arrivalTimes,
             departureTimes: departureTimes,
             pickUpTypes: pickUpTypes,
@@ -15953,6 +16362,9 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
                 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) {
@@ -15989,11 +16401,19 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds)
         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) {
@@ -16072,24 +16492,27 @@ class GtfsParser {
             const tripsEnd = performance.now();
             log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
             let transfers = new Map();
+            let tripContinuations = 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 { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, } = yield parseTransfers(transfersStream, parsedStops);
+                transfers = parsedTransfers;
+                tripContinuations = parsedTripContinuations;
                 const transfersEnd = performance.now();
-                log.info(`${transfers.size} valid transfers. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
+                log.info(`${transfers.size} valid transfers and ${tripContinuations.size} trip continuations. (${(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 { routes, serviceRoutesMap, tripsMapping } = 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 stopsAdjacency = buildStopsAdjacencyStructure(tripsMapping, serviceRoutes, routes, transfers, tripContinuations, parsedStops.size, activeStopIds);
             const stopsAdjacencyEnd = performance.now();
             log.info(`${stopsAdjacency.length} valid stops in the structure. (${(stopsAdjacencyEnd - stopsAdjacencyStart).toFixed(2)}ms)`);
             yield zip.close();