minotor 3.0.2 → 5.0.0

package/dist/parser.cjs.js

@@ -24,6 +24,18 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
 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) {
@@ -12311,148 +12323,6 @@ const Route$1 = {
         return message;
     },
 };
-function createBaseRoutesAdjacency() {
-    return { routes: {} };
-}
-const RoutesAdjacency = {
-    encode(message, writer = new BinaryWriter()) {
-        Object.entries(message.routes).forEach(([key, value]) => {
-            RoutesAdjacency_RoutesEntry.encode({ key: key, value }, writer.uint32(10).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 = createBaseRoutesAdjacency();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1: {
-                    if (tag !== 10) {
-                        break;
-                    }
-                    const entry1 = RoutesAdjacency_RoutesEntry.decode(reader, reader.uint32());
-                    if (entry1.value !== undefined) {
-                        message.routes[entry1.key] = entry1.value;
-                    }
-                    continue;
-                }
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skip(tag & 7);
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            routes: isObject(object.routes)
-                ? Object.entries(object.routes).reduce((acc, [key, value]) => {
-                    acc[key] = Route$1.fromJSON(value);
-                    return acc;
-                }, {})
-                : {},
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.routes) {
-            const entries = Object.entries(message.routes);
-            if (entries.length > 0) {
-                obj.routes = {};
-                entries.forEach(([k, v]) => {
-                    obj.routes[k] = Route$1.toJSON(v);
-                });
-            }
-        }
-        return obj;
-    },
-    create(base) {
-        return RoutesAdjacency.fromPartial(base !== null && base !== void 0 ? base : {});
-    },
-    fromPartial(object) {
-        var _a;
-        const message = createBaseRoutesAdjacency();
-        message.routes = Object.entries((_a = object.routes) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
-            if (value !== undefined) {
-                acc[key] = Route$1.fromPartial(value);
-            }
-            return acc;
-        }, {});
-        return message;
-    },
-};
-function createBaseRoutesAdjacency_RoutesEntry() {
-    return { key: "", value: undefined };
-}
-const RoutesAdjacency_RoutesEntry = {
-    encode(message, writer = new BinaryWriter()) {
-        if (message.key !== "") {
-            writer.uint32(10).string(message.key);
-        }
-        if (message.value !== undefined) {
-            Route$1.encode(message.value, 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 = createBaseRoutesAdjacency_RoutesEntry();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1: {
-                    if (tag !== 10) {
-                        break;
-                    }
-                    message.key = reader.string();
-                    continue;
-                }
-                case 2: {
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.value = Route$1.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.String(object.key) : "",
-            value: isSet(object.value) ? Route$1.fromJSON(object.value) : undefined,
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.key !== "") {
-            obj.key = message.key;
-        }
-        if (message.value !== undefined) {
-            obj.value = Route$1.toJSON(message.value);
-        }
-        return obj;
-    },
-    create(base) {
-        return RoutesAdjacency_RoutesEntry.fromPartial(base !== null && base !== void 0 ? base : {});
-    },
-    fromPartial(object) {
-        var _a;
-        const message = createBaseRoutesAdjacency_RoutesEntry();
-        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
-        message.value = (object.value !== undefined && object.value !== null) ? Route$1.fromPartial(object.value) : undefined;
-        return message;
-    },
-};
 function createBaseTransfer() {
     return { destination: 0, type: 0, minTransferTime: undefined };
 }
@@ -12465,7 +12335,7 @@ const Transfer = {
             writer.uint32(16).int32(message.type);
         }
         if (message.minTransferTime !== undefined) {
-            writer.uint32(24).int32(message.minTransferTime);
+            writer.uint32(24).uint32(message.minTransferTime);
         }
         return writer;
     },
@@ -12494,7 +12364,7 @@ const Transfer = {
                     if (tag !== 24) {
                         break;
                     }
-                    message.minTransferTime = reader.int32();
+                    message.minTransferTime = reader.uint32();
                     continue;
                 }
             }
@@ -12576,7 +12446,7 @@ const StopsAdjacency = {
         return {
             stops: isObject(object.stops)
                 ? Object.entries(object.stops).reduce((acc, [key, value]) => {
-                    acc[key] = StopsAdjacency_StopAdjacency.fromJSON(value);
+                    acc[globalThis.Number(key)] = StopsAdjacency_StopAdjacency.fromJSON(value);
                     return acc;
                 }, {})
                 : {},
@@ -12603,7 +12473,7 @@ const StopsAdjacency = {
         const message = createBaseStopsAdjacency();
         message.stops = Object.entries((_a = object.stops) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {
-                acc[key] = StopsAdjacency_StopAdjacency.fromPartial(value);
+                acc[globalThis.Number(key)] = StopsAdjacency_StopAdjacency.fromPartial(value);
             }
             return acc;
         }, {});
@@ -12618,9 +12488,11 @@ const StopsAdjacency_StopAdjacency = {
         for (const v of message.transfers) {
             Transfer.encode(v, writer.uint32(10).fork()).join();
         }
+        writer.uint32(18).fork();
         for (const v of message.routes) {
-            writer.uint32(18).string(v);
+            writer.int32(v);
         }
+        writer.join();
         return writer;
     },
     decode(input, length) {
@@ -12638,11 +12510,18 @@ const StopsAdjacency_StopAdjacency = {
                     continue;
                 }
                 case 2: {
-                    if (tag !== 18) {
-                        break;
+                    if (tag === 16) {
+                        message.routes.push(reader.int32());
+                        continue;
                     }
-                    message.routes.push(reader.string());
-                    continue;
+                    if (tag === 18) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.routes.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
                 }
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -12657,7 +12536,7 @@ const StopsAdjacency_StopAdjacency = {
             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.String(e)) : [],
+            routes: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routes) ? object.routes.map((e) => globalThis.Number(e)) : [],
         };
     },
     toJSON(message) {
@@ -12667,7 +12546,7 @@ const StopsAdjacency_StopAdjacency = {
             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;
+            obj.routes = message.routes.map((e) => Math.round(e));
         }
         return obj;
     },
@@ -12683,12 +12562,12 @@ const StopsAdjacency_StopAdjacency = {
     },
 };
 function createBaseStopsAdjacency_StopsEntry() {
-    return { key: "", value: undefined };
+    return { key: 0, value: undefined };
 }
 const StopsAdjacency_StopsEntry = {
     encode(message, writer = new BinaryWriter()) {
-        if (message.key !== "") {
-            writer.uint32(10).string(message.key);
+        if (message.key !== 0) {
+            writer.uint32(8).uint32(message.key);
         }
         if (message.value !== undefined) {
             StopsAdjacency_StopAdjacency.encode(message.value, writer.uint32(18).fork()).join();
@@ -12703,10 +12582,10 @@ const StopsAdjacency_StopsEntry = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1: {
-                    if (tag !== 10) {
+                    if (tag !== 8) {
                         break;
                     }
-                    message.key = reader.string();
+                    message.key = reader.uint32();
                     continue;
                 }
                 case 2: {
@@ -12726,14 +12605,14 @@ const StopsAdjacency_StopsEntry = {
     },
     fromJSON(object) {
         return {
-            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            key: isSet(object.key) ? globalThis.Number(object.key) : 0,
             value: isSet(object.value) ? StopsAdjacency_StopAdjacency.fromJSON(object.value) : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        if (message.key !== "") {
-            obj.key = message.key;
+        if (message.key !== 0) {
+            obj.key = Math.round(message.key);
         }
         if (message.value !== undefined) {
             obj.value = StopsAdjacency_StopAdjacency.toJSON(message.value);
@@ -12746,7 +12625,7 @@ const StopsAdjacency_StopsEntry = {
     fromPartial(object) {
         var _a;
         const message = createBaseStopsAdjacency_StopsEntry();
-        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : 0;
         message.value = (object.value !== undefined && object.value !== null)
             ? StopsAdjacency_StopAdjacency.fromPartial(object.value)
             : undefined;
@@ -12754,7 +12633,7 @@ const StopsAdjacency_StopsEntry = {
     },
 };
 function createBaseServiceRoute() {
-    return { type: 0, name: "" };
+    return { type: 0, name: "", routes: [] };
 }
 const ServiceRoute = {
     encode(message, writer = new BinaryWriter()) {
@@ -12764,6 +12643,11 @@ const ServiceRoute = {
         if (message.name !== "") {
             writer.uint32(18).string(message.name);
         }
+        writer.uint32(26).fork();
+        for (const v of message.routes) {
+            writer.int32(v);
+        }
+        writer.join();
         return writer;
     },
     decode(input, length) {
@@ -12787,6 +12671,20 @@ const ServiceRoute = {
                     message.name = reader.string();
                     continue;
                 }
+                case 3: {
+                    if (tag === 24) {
+                        message.routes.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 26) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.routes.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -12799,9 +12697,11 @@ 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)) : [],
         };
     },
     toJSON(message) {
+        var _a;
         const obj = {};
         if (message.type !== 0) {
             obj.type = routeTypeToJSON(message.type);
@@ -12809,16 +12709,20 @@ const ServiceRoute = {
         if (message.name !== "") {
             obj.name = message.name;
         }
+        if ((_a = message.routes) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.routes = message.routes.map((e) => Math.round(e));
+        }
         return obj;
     },
     create(base) {
         return ServiceRoute.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b;
+        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)) || [];
         return message;
     },
 };
@@ -12967,7 +12871,7 @@ const ServiceRoutesMap_RoutesEntry = {
     },
 };
 function createBaseTimetable() {
-    return { version: "", stopsAdjacency: undefined, routesAdjacency: undefined, routes: undefined };
+    return { version: "", stopsAdjacency: undefined, routesAdjacency: [], routes: undefined };
 }
 const Timetable$1 = {
     encode(message, writer = new BinaryWriter()) {
@@ -12977,8 +12881,8 @@ const Timetable$1 = {
         if (message.stopsAdjacency !== undefined) {
             StopsAdjacency.encode(message.stopsAdjacency, writer.uint32(18).fork()).join();
         }
-        if (message.routesAdjacency !== undefined) {
-            RoutesAdjacency.encode(message.routesAdjacency, writer.uint32(26).fork()).join();
+        for (const v of message.routesAdjacency) {
+            Route$1.encode(v, writer.uint32(26).fork()).join();
         }
         if (message.routes !== undefined) {
             ServiceRoutesMap.encode(message.routes, writer.uint32(34).fork()).join();
@@ -13010,7 +12914,7 @@ const Timetable$1 = {
                     if (tag !== 26) {
                         break;
                     }
-                    message.routesAdjacency = RoutesAdjacency.decode(reader, reader.uint32());
+                    message.routesAdjacency.push(Route$1.decode(reader, reader.uint32()));
                     continue;
                 }
                 case 4: {
@@ -13032,11 +12936,14 @@ const Timetable$1 = {
         return {
             version: isSet(object.version) ? globalThis.String(object.version) : "",
             stopsAdjacency: isSet(object.stopsAdjacency) ? StopsAdjacency.fromJSON(object.stopsAdjacency) : undefined,
-            routesAdjacency: isSet(object.routesAdjacency) ? RoutesAdjacency.fromJSON(object.routesAdjacency) : undefined,
+            routesAdjacency: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.routesAdjacency)
+                ? object.routesAdjacency.map((e) => Route$1.fromJSON(e))
+                : [],
             routes: isSet(object.routes) ? ServiceRoutesMap.fromJSON(object.routes) : undefined,
         };
     },
     toJSON(message) {
+        var _a;
         const obj = {};
         if (message.version !== "") {
             obj.version = message.version;
@@ -13044,8 +12951,8 @@ const Timetable$1 = {
         if (message.stopsAdjacency !== undefined) {
             obj.stopsAdjacency = StopsAdjacency.toJSON(message.stopsAdjacency);
         }
-        if (message.routesAdjacency !== undefined) {
-            obj.routesAdjacency = RoutesAdjacency.toJSON(message.routesAdjacency);
+        if ((_a = message.routesAdjacency) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.routesAdjacency = message.routesAdjacency.map((e) => Route$1.toJSON(e));
         }
         if (message.routes !== undefined) {
             obj.routes = ServiceRoutesMap.toJSON(message.routes);
@@ -13056,15 +12963,13 @@ const Timetable$1 = {
         return Timetable$1.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a;
+        var _a, _b;
         const message = createBaseTimetable();
         message.version = (_a = object.version) !== null && _a !== void 0 ? _a : "";
         message.stopsAdjacency = (object.stopsAdjacency !== undefined && object.stopsAdjacency !== null)
             ? StopsAdjacency.fromPartial(object.stopsAdjacency)
             : undefined;
-        message.routesAdjacency = (object.routesAdjacency !== undefined && object.routesAdjacency !== null)
-            ? RoutesAdjacency.fromPartial(object.routesAdjacency)
-            : undefined;
+        message.routesAdjacency = ((_b = object.routesAdjacency) === null || _b === void 0 ? void 0 : _b.map((e) => Route$1.fromPartial(e))) || [];
         message.routes = (object.routes !== undefined && object.routes !== null)
             ? ServiceRoutesMap.fromPartial(object.routes)
             : undefined;
@@ -13444,11 +13349,16 @@ class Route {
      * @returns The pick-up type at the specified stop and trip.
      */
     pickUpTypeFrom(stopId, tripIndex) {
-        const pickUpIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2;
-        const pickUpValue = this.pickUpDropOffTypes[pickUpIndex];
-        if (pickUpValue === undefined) {
+        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        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}`);
         }
+        const pickUpValue = isSecondPair
+            ? (byte >> 6) & 0x03 // Upper 2 bits for second pair
+            : (byte >> 2) & 0x03; // Bits 2-3 for first pair
         return toPickupDropOffType(pickUpValue);
     }
     /**
@@ -13459,11 +13369,16 @@ class Route {
      * @returns The drop-off type at the specified stop and trip.
      */
     dropOffTypeAt(stopId, tripIndex) {
-        const dropOffIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2 + 1;
-        const dropOffValue = this.pickUpDropOffTypes[dropOffIndex];
-        if (dropOffValue === undefined) {
+        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        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}`);
         }
+        const dropOffValue = isSecondPair
+            ? (byte >> 4) & 0x03 // Bits 4-5 for second pair
+            : byte & 0x03; // Lower 2 bits for first pair
         return toPickupDropOffType(dropOffValue);
     }
     /**
@@ -13618,17 +13533,15 @@ const serializeStopsAdjacency = (stopsAdjacency) => {
     return protoStopsAdjacency;
 };
 const serializeRoutesAdjacency = (routesAdjacency) => {
-    const protoRoutesAdjacency = {
-        routes: {},
-    };
-    routesAdjacency.forEach((route, key) => {
+    const protoRoutesAdjacency = [];
+    routesAdjacency.forEach((route) => {
         const routeData = route.serialize();
-        protoRoutesAdjacency.routes[key] = {
+        protoRoutesAdjacency.push({
             stopTimes: uint16ArrayToBytes(routeData.stopTimes),
             pickUpDropOffTypes: routeData.pickUpDropOffTypes,
             stops: uint32ArrayToBytes(routeData.stops),
             serviceRouteId: routeData.serviceRouteId,
-        };
+        });
     });
     return protoRoutesAdjacency;
 };
@@ -13640,6 +13553,7 @@ const serializeServiceRoutesMap = (serviceRoutesMap) => {
         protoServiceRoutesMap.routes[key] = {
             type: serializeRouteType(value.type),
             name: value.name,
+            routes: value.routes,
         };
     });
     return protoServiceRoutesMap;
@@ -13658,10 +13572,10 @@ const deserializeStopsAdjacency = (protoStopsAdjacency) => {
     return stopsAdjacency;
 };
 const deserializeRoutesAdjacency = (protoRoutesAdjacency) => {
-    const routesAdjacency = new Map();
-    Object.entries(protoRoutesAdjacency.routes).forEach(([key, value]) => {
+    const routesAdjacency = [];
+    protoRoutesAdjacency.forEach((value) => {
         const stops = bytesToUint32Array(value.stops);
-        routesAdjacency.set(key, new Route(bytesToUint16Array(value.stopTimes), value.pickUpDropOffTypes, stops, value.serviceRouteId));
+        routesAdjacency.push(new Route(bytesToUint16Array(value.stopTimes), value.pickUpDropOffTypes, stops, value.serviceRouteId));
     });
     return routesAdjacency;
 };
@@ -13671,6 +13585,7 @@ const deserializeServiceRoutesMap = (protoServiceRoutesMap) => {
         serviceRoutesMap.set(key, {
             type: parseRouteType(value.type),
             name: value.name,
+            routes: value.routes,
         });
     });
     return serviceRoutesMap;
@@ -13765,7 +13680,7 @@ const ALL_TRANSPORT_MODES = new Set([
     'TROLLEYBUS',
     'MONORAIL',
 ]);
-const CURRENT_VERSION = '0.0.3';
+const CURRENT_VERSION = '0.0.5';
 /**
  * The internal transit timetable format.
  */
@@ -13805,9 +13720,7 @@ class Timetable {
         }
         return new Timetable(
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        deserializeStopsAdjacency(protoTimetable.stopsAdjacency), deserializeRoutesAdjacency(
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        protoTimetable.routesAdjacency), 
+        deserializeStopsAdjacency(protoTimetable.stopsAdjacency), deserializeRoutesAdjacency(protoTimetable.routesAdjacency), 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         deserializeServiceRoutesMap(protoTimetable.routes));
     }
@@ -13819,7 +13732,7 @@ class Timetable {
      * or undefined if no such route exists.
      */
     getRoute(routeId) {
-        return this.routesAdjacency.get(routeId);
+        return this.routesAdjacency[routeId];
     }
     /**
      * Retrieves all transfer options available at the specified stop.
@@ -13839,9 +13752,14 @@ class Timetable {
      * @param route - The route for which the service route is to be retrieved.
      * @returns The service route corresponding to the provided route.
      */
-    getServiceRoute(route) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return this.routes.get(route.serviceRoute());
+    getServiceRouteInfo(route) {
+        const serviceRoute = this.routes.get(route.serviceRoute());
+        if (!serviceRoute) {
+            throw new Error(`Service route not found for route ID: ${route.serviceRoute()}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { routes } = serviceRoute, serviceRouteInfo = __rest(serviceRoute, ["routes"]);
+        return serviceRouteInfo;
     }
     /**
      * Finds all routes passing through a stop.
@@ -13856,7 +13774,7 @@ class Timetable {
         }
         const routes = [];
         for (const routeId of stopData.routes) {
-            const route = this.routesAdjacency.get(routeId);
+            const route = this.routesAdjacency[routeId];
             if (route) {
                 routes.push(route);
             }
@@ -13876,7 +13794,7 @@ class Timetable {
         const reachableRoutes = new Map();
         for (const originStop of fromStops) {
             const validRoutes = this.routesPassingThrough(originStop).filter((route) => {
-                const serviceRoute = this.getServiceRoute(route);
+                const serviceRoute = this.getServiceRouteInfo(route);
                 return transportModes.has(serviceRoute.type);
             });
             for (const route of validRoutes) {
@@ -15887,6 +15805,7 @@ const parseRoutes = (routesStream_1, ...args_1) => __awaiter(void 0, [routesStre
             routes.set(line.route_id, {
                 name: line.route_short_name,
                 type: routeType,
+                routes: [],
             });
         }
     }
@@ -16196,15 +16115,95 @@ const parseGtfsTransferType = (gtfsTransferType) => {
     }
 };
 
+/**
+ * Encodes pickup/drop-off types into a Uint8Array using 2 bits per value.
+ * Layout per byte: [drop_off_1][pickup_1][drop_off_0][pickup_0] for stops 0 and 1
+ */
+const encodePickUpDropOffTypes = (pickUpTypes, dropOffTypes) => {
+    const stopsCount = pickUpTypes.length;
+    // Each byte stores 2 pickup/drop-off pairs (4 bits each)
+    const arraySize = Math.ceil(stopsCount / 2);
+    const encoded = new Uint8Array(arraySize);
+    for (let i = 0; i < stopsCount; i++) {
+        const byteIndex = Math.floor(i / 2);
+        const isSecondPair = i % 2 === 1;
+        const dropOffType = dropOffTypes[i];
+        const pickUpType = pickUpTypes[i];
+        if (dropOffType !== undefined &&
+            pickUpType !== undefined &&
+            byteIndex < encoded.length) {
+            if (isSecondPair) {
+                // Second pair: upper 4 bits
+                const currentByte = encoded[byteIndex];
+                if (currentByte !== undefined) {
+                    encoded[byteIndex] =
+                        currentByte | (dropOffType << 4) | (pickUpType << 6);
+                }
+            }
+            else {
+                // First pair: lower 4 bits
+                const currentByte = encoded[byteIndex];
+                if (currentByte !== undefined) {
+                    encoded[byteIndex] = currentByte | dropOffType | (pickUpType << 2);
+                }
+            }
+        }
+    }
+    return encoded;
+};
+/**
+ * Sorts trips by departure time and creates optimized typed arrays
+ */
+const finalizeRouteFromBuilder = (builder) => {
+    builder.trips.sort((a, b) => a.firstDeparture - b.firstDeparture);
+    const stopsCount = builder.stops.length;
+    const tripsCount = builder.trips.length;
+    const stopsArray = new Uint32Array(builder.stops);
+    const stopTimesArray = new Uint16Array(stopsCount * tripsCount * 2);
+    const allPickUpTypes = [];
+    const allDropOffTypes = [];
+    for (let tripIndex = 0; tripIndex < tripsCount; tripIndex++) {
+        const trip = builder.trips[tripIndex];
+        if (!trip) {
+            throw new Error(`Missing trip data at index ${tripIndex}`);
+        }
+        const baseIndex = tripIndex * stopsCount * 2;
+        for (let stopIndex = 0; stopIndex < stopsCount; stopIndex++) {
+            const timeIndex = baseIndex + stopIndex * 2;
+            const arrivalTime = trip.arrivalTimes[stopIndex];
+            const departureTime = trip.departureTimes[stopIndex];
+            const pickUpType = trip.pickUpTypes[stopIndex];
+            const dropOffType = trip.dropOffTypes[stopIndex];
+            if (arrivalTime === undefined ||
+                departureTime === undefined ||
+                pickUpType === undefined ||
+                dropOffType === undefined) {
+                throw new Error(`Missing trip data for trip ${tripIndex} at stop ${stopIndex}`);
+            }
+            stopTimesArray[timeIndex] = arrivalTime;
+            stopTimesArray[timeIndex + 1] = departureTime;
+            allDropOffTypes.push(dropOffType);
+            allPickUpTypes.push(pickUpType);
+        }
+    }
+    // Use 2-bit encoding for pickup/drop-off types
+    const pickUpDropOffTypesArray = encodePickUpDropOffTypes(allPickUpTypes, allDropOffTypes);
+    return {
+        serviceRouteId: builder.serviceRouteId,
+        stops: stopsArray,
+        stopTimes: stopTimesArray,
+        pickUpDropOffTypes: pickUpDropOffTypesArray,
+    };
+};
 /**
  * Parses the trips.txt file from a GTFS feed
  *
  * @param tripsStream The readable stream containing the trips data.
  * @param serviceIds A mapping of service IDs to corresponding route IDs.
- * @param routeIds A mapping of route IDs to route details.
+ * @param serviceRoutes A mapping of route IDs to route details.
  * @returns A mapping of trip IDs to corresponding route IDs.
  */
-const parseTrips = (tripsStream, serviceIds, routeIds) => __awaiter(void 0, void 0, void 0, function* () {
+const parseTrips = (tripsStream, serviceIds, serviceRoutes) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, e_1, _b, _c;
     const trips = new Map();
     try {
@@ -16217,7 +16216,7 @@ const parseTrips = (tripsStream, serviceIds, routeIds) => __awaiter(void 0, void
                 // The trip doesn't correspond to an active service
                 continue;
             }
-            if (!routeIds.get(line.route_id)) {
+            if (!serviceRoutes.get(line.route_id)) {
                 // The trip doesn't correspond to a supported route
                 continue;
             }
@@ -16233,21 +16232,22 @@ const parseTrips = (tripsStream, serviceIds, routeIds) => __awaiter(void 0, void
     }
     return trips;
 });
-const buildStopsAdjacencyStructure = (validStops, routes, transfersMap) => {
-    var _a;
+const buildStopsAdjacencyStructure = (validStops, serviceRoutes, routes, transfersMap) => {
     const stopsAdjacency = new Map();
-    for (const routeId of routes.keys()) {
-        const route = routes.get(routeId);
-        if (!route) {
-            throw new Error(`Route ${routeId} not found`);
-        }
+    routes.forEach((route, index) => {
+        var _a;
         for (const stop of route.stopsIterator()) {
             if (!stopsAdjacency.get(stop) && validStops.has(stop)) {
                 stopsAdjacency.set(stop, { routes: [], transfers: [] });
             }
-            (_a = stopsAdjacency.get(stop)) === null || _a === void 0 ? void 0 : _a.routes.push(routeId);
+            (_a = stopsAdjacency.get(stop)) === null || _a === void 0 ? void 0 : _a.routes.push(index);
         }
-    }
+        const serviceRoute = serviceRoutes.get(route.serviceRoute());
+        if (!serviceRoute) {
+            throw new Error(`Service route ${route.serviceRoute()} not found for route ${index}.`);
+        }
+        serviceRoute.routes.push(index);
+    });
     for (const [stop, transfers] of transfersMap) {
         const s = stopsAdjacency.get(stop);
         if (s) {
@@ -16273,11 +16273,11 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
     var _a, e_2, _b, _c;
     var _d, _e;
     /**
-     * Inserts a trip at the right place in the routes adjacency structure.
+     * Adds a trip to the appropriate route builder
      */
     const addTrip = (currentTripId) => {
         const gtfsRouteId = validTripIds.get(currentTripId);
-        if (!gtfsRouteId) {
+        if (!gtfsRouteId || stops.length === 0) {
             stops = [];
             arrivalTimes = [];
             departureTimes = [];
@@ -16286,83 +16286,42 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
             return;
         }
         const routeId = `${gtfsRouteId}_${hashIds(stops)}`;
-        let route = routes.get(routeId);
-        if (!route) {
-            const stopsCount = stops.length;
-            const stopsArray = new Uint32Array(stops);
-            const stopTimesArray = new Uint16Array(stopsCount * 2);
-            for (let i = 0; i < stopsCount; i++) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                stopTimesArray[i * 2] = arrivalTimes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                stopTimesArray[i * 2 + 1] = departureTimes[i];
-            }
-            const pickUpDropOffTypesArray = new Uint8Array(stopsCount * 2);
-            for (let i = 0; i < stopsCount; i++) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                pickUpDropOffTypesArray[i * 2] = pickUpTypes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                pickUpDropOffTypesArray[i * 2 + 1] = dropOffTypes[i];
-            }
-            route = {
+        const firstDeparture = departureTimes[0];
+        if (firstDeparture === undefined) {
+            console.warn(`Empty trip ${currentTripId}`);
+            stops = [];
+            arrivalTimes = [];
+            departureTimes = [];
+            pickUpTypes = [];
+            dropOffTypes = [];
+            return;
+        }
+        let routeBuilder = routeBuilders.get(routeId);
+        if (!routeBuilder) {
+            routeBuilder = {
                 serviceRouteId: gtfsRouteId,
-                stops: stopsArray,
-                stopTimes: stopTimesArray,
-                pickUpDropOffTypes: pickUpDropOffTypesArray,
+                stops: [...stops],
+                trips: [],
             };
-            routes.set(routeId, route);
+            routeBuilders.set(routeId, routeBuilder);
             for (const stop of stops) {
                 validStopIds.add(stop);
             }
         }
-        else {
-            const tripFirstStopDeparture = departureTimes[0];
-            if (tripFirstStopDeparture === undefined) {
-                throw new Error(`Empty trip ${currentTripId}`);
-            }
-            // Find the correct position to insert the new trip
-            const stopsCount = stops.length;
-            let insertPosition = 0;
-            const existingTripsCount = route.stopTimes.length / (stopsCount * 2);
-            for (let tripIndex = 0; tripIndex < existingTripsCount; tripIndex++) {
-                const currentDeparture = route.stopTimes[tripIndex * stopsCount * 2 + 1];
-                if (currentDeparture && tripFirstStopDeparture > currentDeparture) {
-                    insertPosition = (tripIndex + 1) * stopsCount;
-                }
-                else {
-                    break;
-                }
-            }
-            // insert data for the new trip at the right place
-            const newStopTimesLength = route.stopTimes.length + stopsCount * 2;
-            const newStopTimes = new Uint16Array(newStopTimesLength);
-            const newPickUpDropOffTypes = new Uint8Array(newStopTimesLength);
-            newStopTimes.set(route.stopTimes.slice(0, insertPosition * 2), 0);
-            newPickUpDropOffTypes.set(route.pickUpDropOffTypes.slice(0, insertPosition * 2), 0);
-            for (let i = 0; i < stopsCount; i++) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newStopTimes[(insertPosition + i) * 2] = arrivalTimes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newStopTimes[(insertPosition + i) * 2 + 1] = departureTimes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newPickUpDropOffTypes[(insertPosition + i) * 2] = pickUpTypes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newPickUpDropOffTypes[(insertPosition + i) * 2 + 1] = dropOffTypes[i];
-            }
-            const afterInsertionSlice = route.stopTimes.slice(insertPosition * 2);
-            newStopTimes.set(afterInsertionSlice, (insertPosition + stopsCount) * 2);
-            const afterInsertionTypesSlice = route.pickUpDropOffTypes.slice(insertPosition * 2);
-            newPickUpDropOffTypes.set(afterInsertionTypesSlice, (insertPosition + stopsCount) * 2);
-            route.stopTimes = newStopTimes;
-            route.pickUpDropOffTypes = newPickUpDropOffTypes;
-        }
+        routeBuilder.trips.push({
+            firstDeparture,
+            arrivalTimes: [...arrivalTimes],
+            departureTimes: [...departureTimes],
+            pickUpTypes: [...pickUpTypes],
+            dropOffTypes: [...dropOffTypes],
+        });
         stops = [];
         arrivalTimes = [];
         departureTimes = [];
         pickUpTypes = [];
         dropOffTypes = [];
     };
-    const routes = new Map();
+    const routeBuilders = new Map();
     let previousSeq = 0;
     let stops = [];
     let arrivalTimes = [];
@@ -16377,27 +16336,33 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
             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}.`);
+                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) {
+            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;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            stops.push(stopsMap.get(line.stop_id).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;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            if (!arrival || !departure) {
+                console.warn(`Missing time data for ${line.trip_id} at stop ${line.stop_id}`);
+                continue;
+            }
             arrivalTimes.push(toTime(arrival).toMinutes());
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             departureTimes.push(toTime(departure).toMinutes());
             pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
             dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
@@ -16414,9 +16379,10 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
     if (currentTripId) {
         addTrip(currentTripId);
     }
-    const routesAdjacency = new Map();
-    for (const [routeId, routeData] of routes) {
-        routesAdjacency.set(routeId, new Route(routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
+    const routesAdjacency = [];
+    for (const [, routeBuilder] of routeBuilders) {
+        const routeData = finalizeRouteFromBuilder(routeBuilder);
+        routesAdjacency.push(new Route(routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
     }
     return routesAdjacency;
 });
@@ -16424,13 +16390,13 @@ const parsePickupDropOffType = (gtfsType) => {
     switch (gtfsType) {
         default:
             return REGULAR;
-        case 0:
+        case '0':
             return REGULAR;
-        case 1:
+        case '1':
             return NOT_AVAILABLE;
-        case 2:
+        case '2':
             return MUST_PHONE_AGENCY;
-        case 3:
+        case '3':
             return MUST_COORDINATE_WITH_DRIVER;
     }
 };
@@ -16458,54 +16424,74 @@ class GtfsParser {
      */
     parse(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 validServiceIds = new Set();
             const validStopIds = new Set();
             log.info(`Parsing ${STOPS_FILE}`);
+            const stopsStart = performance.now();
             const stopsStream = yield zip.stream(STOPS_FILE);
             const parsedStops = yield parseStops(stopsStream, this.profile.platformParser);
-            log.info(`${parsedStops.size} parsed stops.`);
+            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, validServiceIds, datetime);
-                log.info(`${validServiceIds.size} valid services.`);
+                const calendarEnd = performance.now();
+                log.info(`${validServiceIds.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, validServiceIds, datetime);
-                log.info(`${validServiceIds.size} valid services.`);
+                const calendarDatesEnd = performance.now();
+                log.info(`${validServiceIds.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);
-            log.info(`${validGtfsRoutes.size} valid GTFS routes.`);
+            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, validServiceIds, validGtfsRoutes);
-            log.info(`${trips.size} valid trips.`);
+            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);
-                log.info(`${transfers.size} valid transfers.`);
+                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 routesAdjacency = yield parseStopTimes(stopTimesStream, parsedStops, trips, validStopIds);
-            const stopsAdjacency = buildStopsAdjacencyStructure(validStopIds, routesAdjacency, transfers);
-            log.info(`${routesAdjacency.size} valid unique routes.`);
+            const stopsAdjacency = buildStopsAdjacencyStructure(validStopIds, validGtfsRoutes, routesAdjacency, transfers);
+            const stopTimesEnd = performance.now();
+            log.info(`${routesAdjacency.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
             log.info(`Removing unused stops.`);
+            const indexStopsStart = performance.now();
             const stops = indexStops(parsedStops, validStopIds);
-            log.info(`${stops.size} used stop stops, ${parsedStops.size - stops.size} unused.`);
+            const indexStopsEnd = performance.now();
+            log.info(`${stops.size} used stop stops, ${parsedStops.size - stops.size} unused. (${(indexStopsEnd - indexStopsStart).toFixed(2)}ms)`);
             yield zip.close();
             const timetable = new Timetable(stopsAdjacency, routesAdjacency, validGtfsRoutes);
             log.info(`Building stops index.`);
+            const stopsIndexStart = performance.now();
             const stopsIndex = new StopsIndex(stops);
+            const stopsIndexEnd = performance.now();
+            log.info(`Stops index built. (${(stopsIndexEnd - stopsIndexStart).toFixed(2)}ms)`);
             log.info('Parsing complete.');
             return { timetable, stopsIndex };
         });
@@ -16521,9 +16507,11 @@ class GtfsParser {
         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 = indexStops(yield parseStops(stopsStream, this.profile.platformParser));
-            log.info(`${stops.size} parsed stops.`);
+            const stopsEnd = performance.now();
+            log.info(`${stops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`);
             yield zip.close();
             return new StopsIndex(stops);
         });