@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/esm2015/base/lib/vendor/classes/rail-enterprise-search.js

@@ -0,0 +1,1324 @@
+import { __awaiter } from "tslib";
+import moment from 'moment';
+import { of, combineLatest } from 'rxjs';
+import { map, take, tap } from 'rxjs/operators';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { RailDirection } from './rail-direction.enum';
+import { RailClass, RailJourneyType, ServiceType } from '../types/graphql.types';
+export var RailSearchCriteria;
+(function (RailSearchCriteria) {
+    RailSearchCriteria["Depart"] = "Depart After";
+    RailSearchCriteria["Arrive"] = "Arrive Before";
+})(RailSearchCriteria || (RailSearchCriteria = {}));
+export var RailTicketOptionType;
+(function (RailTicketOptionType) {
+    RailTicketOptionType["Return"] = "Return";
+    RailTicketOptionType["Single"] = "Single";
+})(RailTicketOptionType || (RailTicketOptionType = {}));
+export class RailEnterpriseSearch extends BaseEnterpriseSearch {
+    constructor(Railfetcher, getRailStationFetcher, helpers, basketService, storageService, searchService) {
+        super(storageService);
+        this.Railfetcher = Railfetcher;
+        this.getRailStationFetcher = getRailStationFetcher;
+        this.helpers = helpers;
+        this.basketService = basketService;
+        this.searchService = searchService;
+        this.resultsSessionName = RailEnterpriseSearch.STORAGE_SESSION_RESULTS;
+        this.searchTypes = [
+            { display: 'Return', value: RailJourneyType.ReturnJourney },
+            { display: 'One-Way', value: RailJourneyType.SingleJourney }
+            // { display: 'Open Return', value: RailJourneyType.OpenReturnJourney },
+            // { display: 'Dual Singles', value: RailJourneyType.DualSingleJourney },
+        ];
+        this.classTypes = [
+            { display: 'Any', value: RailClass.All },
+            { display: 'Standard', value: RailClass.Standard },
+            { display: 'First', value: RailClass.First }
+        ];
+        this.airportExpressStations = [
+            { code: 'HP1-3', name: 'Heathrow T1-3 - Paddington' },
+            { code: 'HP4', name: 'Heathrow T4 - Paddington' },
+            { code: 'HP5', name: 'Heathrow T5 - Paddington' },
+            { code: 'PH1-3', name: 'Paddington - Heathrow T1-3' },
+            { code: 'PH4', name: 'Paddington - Heathrow T4' },
+            { code: 'PH5', name: 'Paddington - Heathrow T5' },
+            { code: 'GV', name: 'Gatwick - Victoria' },
+            { code: 'VG', name: 'Victoria - Gatwick' },
+            { code: 'SL', name: 'Stansted - Liverpool Street' },
+            { code: 'LS', name: 'Liverpool Street - Stansted' }
+        ];
+        this.airportExpressStationsCodes = {
+            'HP1-3': { dep: 'HXX', arr: 'PAD' },
+            'PH1-3': { dep: 'PAD', arr: 'HXX' },
+            HP4: { dep: 'HAF', arr: 'PAD' },
+            PH4: { dep: 'PAD', arr: 'HAF' },
+            HP5: { dep: 'HWV', arr: 'PAD' },
+            PH5: { dep: 'PAD', arr: 'HWV' },
+            GV: { dep: 'GTW', arr: 'VIC' },
+            VG: { dep: 'VIC', arr: 'GTW' },
+            SL: { dep: 'SSD', arr: 'LST' },
+            LS: { dep: 'LST', arr: 'SSD' }
+        };
+        this.railCriteria = [RailSearchCriteria.Depart, RailSearchCriteria.Arrive];
+        this.travelCards = [
+            { display: 'Young persons railcard', value: 'YNG' },
+            { display: 'Disability railcard', value: 'DIS' },
+            { display: 'Family railcard', value: 'FAM' },
+            { display: 'Forces railcard', value: 'HMF' },
+            { display: 'Travel agency discount', value: 'TAD' }
+        ];
+        // YNG: "Young persons railcard",
+        // DIS: "Disability railcard",
+        // FAM: "Family railcard",
+        // HMF: "Forces railcard",
+        // TAD: "Travel agency discount"
+        this.removePassingPointsFromResults = true;
+        this.type = ServiceType.Rail;
+        this.minOutboundDate = {
+            year: moment().year(),
+            month: moment().month() + 1,
+            day: moment().date()
+        };
+        this.minInboundDate = {
+            year: moment().year(),
+            month: moment().month() + 1,
+            day: moment().date()
+        };
+        this.maxDate = {
+            // ENT-1557 - max Evolvi search date is 6 months in future
+            year: moment().add('month', 6).year(),
+            month: moment().add('month', 6).month(),
+            day: moment().add('month', 6).date()
+        };
+        // !date and time is handled differently for LU
+        this._outbound_date = null;
+        this._outbound_time = null;
+        this._return_date = null;
+        this._return_time = null;
+        this._cheapestStandard = null;
+        this._cheapestFirst = null;
+        const data = storageService.getSessionItem(RailEnterpriseSearch.STORAGE_SESSION_PARAMS) || {
+            query: {},
+            tempParams: {},
+            originalUserSearch: {}
+        };
+        this.updateTempParams(this.searchService.makeRailQuery(data.tempParams));
+        this._originalUserSearch = data.originalUserSearch;
+        if (this._originalUserSearch && this._originalUserSearch.chosenSearchType) {
+            this.chosenSearchType = this._originalUserSearch.chosenSearchType;
+        }
+        if (searchService.shouldAddTravellerSubscription()) {
+            searchService.travellerInformation.subscribe((travellers) => {
+                this.travellers = travellers;
+                const splitTravellers = this.helpers.selectedTravellers(travellers, ServiceType.Rail);
+                this.tempParams.noOfAdults = splitTravellers.adults.length;
+                this.tempParams.noOfChildren = splitTravellers.children.length;
+                this.travellers = travellers;
+                this._isValid();
+            });
+        }
+        this._isValid();
+        const results = storageService.getSessionItemAsList(this.resultsSessionName) || [];
+        // if (results == null && this.isValid) {
+        //   searchService.startSearches();
+        // }
+        this._cheapestResultPrice = this.updateLowestPrice(results);
+        this.results.next(results || []);
+    }
+    get chosenTicketGroup() {
+        return this._chosenTicketGroup;
+    }
+    get chosenTotalPrice() {
+        if (this._chosenOutboundTicket) {
+            if (this._chosenInboundTicket) {
+                // now check if they are returns or dual
+                if (this._chosenOutboundTicket.singleOrReturn ===
+                    RailTicketOptionType.Return &&
+                    this._chosenInboundTicket.singleOrReturn ===
+                        RailTicketOptionType.Return) {
+                    // they should both have the same price
+                    return this._chosenOutboundTicket.price;
+                }
+                return (this._chosenOutboundTicket.price + this._chosenInboundTicket.price);
+            }
+            return this._chosenOutboundTicket.price;
+        }
+        return 0;
+    }
+    get chosenTickets() {
+        return {
+            Outbound: this._chosenOutboundTicket,
+            Inbound: this._chosenInboundTicket
+        };
+    }
+    get chosenOutboundJourney() {
+        return this._chosenOutboundJourney;
+    }
+    get chosenInboundJourney() {
+        return this._chosenInboundJourney;
+    }
+    get openReturn() {
+        return this.tempParams.openReturn;
+    }
+    set openReturn(newVal) {
+        this.tempParams.openReturn = newVal;
+        if (newVal) {
+            this.tempParams.chosenSearchType = RailJourneyType.OpenReturnJourney;
+        }
+        this._isValid();
+    }
+    get chosenSearchType() {
+        return this.tempParams.chosenSearchType;
+    }
+    set chosenSearchType(newType) {
+        this.tempParams.chosenSearchType = newType;
+        if (newType === RailJourneyType.SingleJourney) {
+            this.openReturn = false;
+        }
+        this._isValid();
+    }
+    get noOfAdults() {
+        return this.tempParams.noOfAdults;
+    }
+    set noOfAdults(adults) {
+        this.tempParams.noOfAdults = adults;
+        this._isValid();
+    }
+    get noOfChildren() {
+        return this.tempParams.noOfChildren;
+    }
+    set noOfChildren(children) {
+        this.tempParams.noOfChildren = children;
+        this._isValid();
+    }
+    get travellingTo() {
+        return this.tempParams.travellingTo;
+    }
+    set travellingTo(tt) {
+        var _a;
+        this.tempParams.travellingTo = tt;
+        this._travellingTo = '';
+        if ((_a = tt === null || tt === void 0 ? void 0 : tt.railstation) === null || _a === void 0 ? void 0 : _a.id) {
+            this._travellingTo = tt.railstation.id;
+        }
+        this._isValid();
+    }
+    get travellingFrom() {
+        return this.tempParams.travellingFrom;
+    }
+    set travellingFrom(tt) {
+        var _a;
+        this.tempParams.travellingFrom = tt;
+        this._travellingFrom = '';
+        if ((_a = tt === null || tt === void 0 ? void 0 : tt.railstation) === null || _a === void 0 ? void 0 : _a.id) {
+            this._travellingFrom = tt.railstation.id;
+        }
+        this._isValid();
+    }
+    get chosenRailClass() {
+        return this.tempParams.chosenSearchClass;
+    }
+    set chosenRailClass(newClass) {
+        this.tempParams.chosenSearchClass = newClass;
+    }
+    get chosenSearchClass() {
+        return this.tempParams.chosenSearchClass;
+    }
+    set chosenSearchClass(classR) {
+        this.tempParams.chosenSearchClass = classR;
+        this._isValid();
+    }
+    get extraTime() {
+        return this.tempParams.extraTime;
+    }
+    set extraTime(extra) {
+        this.tempParams.extraTime = extra;
+        this._isValid();
+    }
+    get via() {
+        return this.tempParams.via;
+    }
+    set via(via) {
+        this.tempParams.via = via;
+        this._isValid();
+    }
+    get viaLocation() {
+        return this.tempParams.viaLocation;
+    }
+    set viaLocation(viaLocation) {
+        var _a;
+        this.tempParams.viaLocation = viaLocation;
+        this._viaLocation = '';
+        if ((_a = viaLocation === null || viaLocation === void 0 ? void 0 : viaLocation.railstation) === null || _a === void 0 ? void 0 : _a.id) {
+            this._viaLocation = viaLocation.railstation.id;
+        }
+        this._isValid();
+    }
+    get outBoundDateTime() {
+        return this.tempParams.outBoundDateTime;
+    }
+    set outBoundDateTime(newDateTime) {
+        this.tempParams.outBoundDateTime = newDateTime;
+        if (newDateTime && newDateTime.isValid()) {
+            this._outbound_date = this.helpers.momentToNgDate(newDateTime);
+            this._outbound_time = moment(newDateTime).format('HHmm')
+                ? moment(newDateTime).format('HHmm')
+                : '0700';
+        }
+        this.minInboundDate = {
+            year: newDateTime.year(),
+            month: newDateTime.month() + 1,
+            day: newDateTime.date()
+        };
+        if (this.outBoundDateTime &&
+            this.inBoundDateTime &&
+            this.outBoundDateTime.isAfter(this.inBoundDateTime)) {
+            this.inBoundDateTime = this.inBoundDateTime
+                .set('date', newDateTime.date())
+                .set('month', newDateTime.month())
+                .set('year', newDateTime.year());
+        }
+        this._isValid();
+    }
+    get outboundCriteria() {
+        return this.tempParams.outboundCriteria;
+    }
+    set outboundCriteria(newCrit) {
+        // console.warn(`+++ Setting New Criteria: ${newCrit} +++`);
+        this.tempParams.outboundCriteria = newCrit;
+        this._isValid();
+    }
+    get inBoundDateTime() {
+        return this.tempParams.inBoundDateTime;
+    }
+    set inBoundDateTime(newDateTime) {
+        this.tempParams.inBoundDateTime = newDateTime;
+        if (newDateTime && newDateTime.isValid()) {
+            this._return_date = this.helpers.momentToNgDate(newDateTime);
+            this._return_time = moment(newDateTime).format('HHmm')
+                ? moment(newDateTime).format('HHmm')
+                : '1600';
+        }
+        this._isValid();
+    }
+    get outbound_date() {
+        return this._outbound_date;
+    }
+    set outbound_date(value) {
+        this._outbound_date = value;
+        this._updateOutboundDateTime();
+    }
+    get outbound_time() {
+        return this._outbound_time;
+    }
+    set outbound_time(value) {
+        this._outbound_time = value;
+        this._updateOutboundDateTime();
+    }
+    get return_date() {
+        return this._return_date;
+    }
+    set return_date(value) {
+        this._return_date = value;
+        this._updateReturnDateTime();
+    }
+    get return_time() {
+        return this._return_time;
+    }
+    set return_time(value) {
+        this._return_time = value;
+        this._updateReturnDateTime();
+    }
+    get returnCriteria() {
+        return this.tempParams.returnCriteria;
+    }
+    set returnCriteria(newCrit) {
+        this.tempParams.returnCriteria = newCrit;
+        this._isValid();
+    }
+    get carnetTicket() {
+        return this.tempParams.carnetTicket;
+    }
+    set carnetTicket(newCarnet) {
+        this.tempParams.carnetTicket = newCarnet;
+        this._isValid();
+    }
+    get disableAutoDiscounts() {
+        return this.tempParams.disableAutoDiscounts;
+    }
+    set disableAutoDiscounts(newDis) {
+        this.tempParams.disableAutoDiscounts = newDis;
+        this._isValid();
+    }
+    get prioritiseByPrice() {
+        return this.tempParams.prioritiseByPrice;
+    }
+    set prioritiseByPrice(newPriority) {
+        this.tempParams.prioritiseByPrice = newPriority;
+        this._isValid();
+    }
+    get applyRailcards() {
+        return this.tempParams.applyRailcards;
+    }
+    set applyRailcards(apCards) {
+        this.tempParams.applyRailcards = apCards;
+    }
+    get railCards() {
+        return this.tempParams.railCards;
+    }
+    set railCards(value) {
+        this.tempParams.railCards = value;
+    }
+    get timeArray() {
+        this._timeArray =
+            this._timeArray ||
+                Array(48)
+                    .fill(0)
+                    .map((_, index) => {
+                    return {
+                        value: Math.floor(index / 2)
+                            .toString()
+                            .padStart(2, '0') +
+                            ((index % 2) * 30).toString().padStart(2, '0'),
+                        display: Math.floor(index / 2)
+                            .toString()
+                            .padStart(2, '0') +
+                            ':' +
+                            ((index % 2) * 30).toString().padStart(2, '0')
+                    };
+                });
+        return this._timeArray;
+    }
+    getAirportExpressStations() {
+        return this.airportExpressStations;
+    }
+    get airportExpressStation() {
+        return this.tempParams.airportExpressStation;
+    }
+    set airportExpressStation(station) {
+        this.tempParams.airportExpressStation = station;
+        this._setAirportExpressStations();
+        this._isValid();
+    }
+    get isAirportExpress() {
+        return this.tempParams.isAirportExpress;
+    }
+    set isAirportExpress(value) {
+        this.tempParams.isAirportExpress = value;
+        this.tempParams.openReturn = value;
+        this.tempParams.chosenSearchType = value
+            ? RailJourneyType.OpenReturnJourney
+            : RailJourneyType.ReturnJourney;
+        this._isValid();
+    }
+    setAirportExpressStationIds(stationIds) {
+        const { departureLocationId, arrivalLocationId } = stationIds;
+        if (departureLocationId && arrivalLocationId) {
+            this._travellingFrom = departureLocationId;
+            this._travellingTo = arrivalLocationId;
+            this._isValid();
+        }
+    }
+    get cheapestStandard() {
+        return this._cheapestStandard;
+    }
+    get cheapestFirst() {
+        return this._cheapestFirst;
+    }
+    resetQuery() {
+        this.updateTempParams(this.searchService.makeRailQuery());
+        this._isValid();
+    }
+    _setAirportExpressStations() {
+        const parsedStation = this.airportExpressStationsCodes[this.airportExpressStation];
+        console.log('--- Parsed Station is :', parsedStation);
+        if (parsedStation) {
+            this._travellingFrom = parsedStation.dep;
+            this._travellingTo = parsedStation.arr;
+        }
+    }
+    _isValid() {
+        var _a, _b;
+        this.storageService.setSessionItem(RailEnterpriseSearch.STORAGE_SESSION_PARAMS, {
+            tempParams: this.tempParams,
+            originalUserSearch: this.originalUserSearch
+        });
+        this.validationMessages = [];
+        const now = moment();
+        if (!this._travellingFrom) {
+            this.validationMessages.push('Please Enter a From Location.');
+        }
+        if (!this._travellingTo) {
+            this.validationMessages.push('Please Enter a To Location.');
+        }
+        if ((_a = this.outBoundDateTime) === null || _a === void 0 ? void 0 : _a.isBefore(now)) {
+            this.validationMessages.push('Departure Date/Time cannot be in the past.');
+        }
+        if (this.chosenSearchType === RailJourneyType.ReturnJourney ||
+            this.chosenSearchType === RailJourneyType.DualSingleJourney) {
+            // check for return specific validations in here
+            if ((_b = this.inBoundDateTime) === null || _b === void 0 ? void 0 : _b.isSameOrBefore(this.outBoundDateTime)) {
+                this.validationMessages.push('Return Date/Time must be after Departure Date/Time');
+            }
+        }
+        if (this.via) {
+            if (!this.tempParams.viaLocation) {
+                this.validationMessages.push('Please enter a via location.');
+            }
+        }
+        if (this.tempParams.noOfAdults + this.tempParams.noOfChildren < 1) {
+            this.validationMessages.push('There must be at least 1 traveller');
+        }
+        this.isValid.next(this.validationMessages.length === 0);
+        this.messages.next(this.validationMessages);
+    }
+    startSearch() {
+        this.results.next([]);
+        if (this.isValid.value) {
+            this._originalUserSearch = Object.freeze(Object.assign({}, this.tempParams));
+            this.storageService.setSessionItem(RailEnterpriseSearch.STORAGE_SESSION_PARAMS, {
+                tempParams: this.tempParams,
+                originalUserSearch: this.originalUserSearch
+            });
+            const query = this.getSearchQuery();
+            this.searchService.saveRecentSearch(this.getRecentSearchQuery(query));
+            return this._startSearch(this.Railfetcher.fetchList(query).pipe(map((result) => {
+                if (this.removePassingPointsFromResults) {
+                    result = this._removeCallingPoints(result);
+                }
+                return result;
+            })));
+        }
+        else {
+            return Promise.resolve(false);
+        }
+    }
+    getRecentSearchQuery(query) {
+        const recentSearchQuery = query;
+        if (this.isAirportExpress) {
+            recentSearchQuery.isAirportExpress = this.isAirportExpress;
+        }
+        if (this.airportExpressStation) {
+            recentSearchQuery.airportExpressStation = this.airportExpressStation;
+        }
+        return {
+            serviceType: ServiceType.Rail,
+            searchArgs: recentSearchQuery,
+            travelDate: this.outBoundDateTime.format(),
+            travellers: this.helpers.getTravellersId(this.travellers)
+        };
+    }
+    startRecentSearch(recentSearch) {
+        var _a, _b;
+        this.chosenSearchType = recentSearch.searchArgs.journeyType;
+        this.chosenSearchClass = recentSearch.searchArgs.class;
+        this.extraTime = recentSearch.searchArgs.extraTimeToChange;
+        this.isAirportExpress = recentSearch.searchArgs.isAirportExpress;
+        this.airportExpressStation = recentSearch.searchArgs.airportExpressStation;
+        // get outBoundDateTime, inBoundDateTime and outboundCriteria ,returnCriteria
+        this.outBoundDateTime = recentSearch.searchArgs.outboundDepartureDateTime
+            ? moment(recentSearch.searchArgs.outboundDepartureDateTime)
+            : moment(recentSearch.searchArgs.outboundArrivalDateTime);
+        this.outboundCriteria = this.getCriteria(recentSearch.searchArgs.outboundDepartureDateTime, recentSearch.searchArgs.outboundArrivalDateTime);
+        if (recentSearch.searchArgs.journeyType === RailJourneyType.ReturnJourney) {
+            this.inBoundDateTime = recentSearch.searchArgs.returnDepartureDateTime
+                ? moment(recentSearch.searchArgs.returnDepartureDateTime)
+                : moment(recentSearch.searchArgs.returnArrivalDateTime);
+            this.returnCriteria = this.getCriteria(recentSearch.searchArgs.returnDepartureDateTime, recentSearch.searchArgs.returnArrivalDateTime);
+        }
+        if (recentSearch.searchArgs.journeyType === RailJourneyType.OpenReturnJourney) {
+            this.openReturn = true;
+        }
+        this.applyRailcards = ((_b = (_a = recentSearch.searchArgs) === null || _a === void 0 ? void 0 : _a.railCardQualifiers) === null || _b === void 0 ? void 0 : _b.length) ? true
+            : false;
+        if (this.applyRailcards) {
+            this.railCards = recentSearch.searchArgs.railCardQualifiers;
+        }
+        // get from, to, via
+        combineLatest([
+            this.getRailStationById(recentSearch.searchArgs.departureLocationId),
+            this.getRailStationById(recentSearch.searchArgs.arrivalLocationId)
+        ]).subscribe(([departureStation, arrivalStation]) => {
+            if (departureStation && arrivalStation) {
+                this.travellingTo = {
+                    name: arrivalStation.name,
+                    railstation: {
+                        id: arrivalStation.id,
+                        name: arrivalStation.name,
+                        nlcCode: arrivalStation.nlcCode,
+                        stationCode: arrivalStation.stationCode,
+                        trainlineCode: arrivalStation.trainlineCode,
+                        trainlineUniqueCode: arrivalStation.trainlineUniqueCode
+                    }
+                };
+                this.travellingFrom = {
+                    name: departureStation.name,
+                    railstation: {
+                        id: departureStation.id,
+                        name: departureStation.name,
+                        nlcCode: departureStation.nlcCode,
+                        stationCode: departureStation.stationCode,
+                        trainlineCode: departureStation.trainlineCode,
+                        trainlineUniqueCode: departureStation.trainlineUniqueCode
+                    }
+                };
+                if (recentSearch.searchArgs.viaLocationId) {
+                    this.via = true;
+                    this.getRailStationById(recentSearch.searchArgs.viaLocationId).subscribe((viaLocation) => {
+                        this.viaLocation = {
+                            name: viaLocation.name,
+                            railstation: {
+                                id: viaLocation.id,
+                                name: viaLocation.name,
+                                nlcCode: viaLocation.nlcCode,
+                                stationCode: viaLocation.stationCode,
+                                trainlineCode: viaLocation.trainlineCode,
+                                trainlineUniqueCode: viaLocation.trainlineUniqueCode
+                            }
+                        };
+                        this.searchService.startSearches();
+                    });
+                }
+                this.searchService.startSearches();
+            }
+        });
+    }
+    _removeCallingPoints(journeys) {
+        journeys[0].outbound = journeys[0].outbound.map((outbound) => {
+            outbound.segments.map((segment) => {
+                segment.callingPoints = segment.callingPoints.filter((callingPoint) => callingPoint.stoppingPattern !== RailEnterpriseSearch.PASSING_POINT);
+                return segment;
+            });
+            return outbound;
+        });
+        return journeys;
+    }
+    _updateOutboundDateTime() {
+        if (this._outbound_date && this._outbound_time) {
+            const time = this.helpers.ngDateToMoment(this._outbound_date, this._outbound_time);
+            this.outBoundDateTime = time.isValid() ? time : null;
+            this._isValid();
+        }
+    }
+    _updateReturnDateTime() {
+        if (this._return_date && this._return_time) {
+            const time = this.helpers.ngDateToMoment(this._return_date, this._return_time);
+            this.inBoundDateTime = time.isValid() ? time : null;
+            this._isValid();
+        }
+    }
+    getSearchQuery() {
+        var _a;
+        const query = {
+            countryCode: 'GB',
+            journeyType: this.tempParams.chosenSearchType,
+            adults: this.tempParams.noOfAdults,
+            arrivalLocationId: this._travellingTo,
+            departureLocationId: this._travellingFrom,
+            children: this.tempParams.noOfChildren,
+            class: this.tempParams.chosenSearchClass,
+            extraTimeToChange: this.tempParams.extraTime,
+            outboundArrivalDateTime: this.tempParams.outBoundDateTime,
+            outboundDepartureDateTime: this.tempParams.outBoundDateTime,
+            returnArrivalDateTime: this.tempParams.inBoundDateTime,
+            returnDepartureDateTime: this.tempParams.inBoundDateTime,
+            viaLocationId: this._viaLocation,
+            railCardQualifiers: (_a = this.tempParams.railCards) === null || _a === void 0 ? void 0 : _a.map((railCard) => {
+                return railCard.code;
+            })
+        };
+        if (this.tempParams.noOfChildren === 0) {
+            query.children = null;
+        }
+        if (this._viaLocation === '') {
+            query.viaLocationId = null;
+        }
+        switch (this.tempParams.outboundCriteria) {
+            case RailSearchCriteria.Depart:
+                query.outboundArrivalDateTime = null;
+                break;
+            case RailSearchCriteria.Arrive:
+                query.outboundDepartureDateTime = null;
+                break;
+            default:
+                console.warn(`+++ Unknown Criteria: ${this.tempParams.outboundCriteria} +++`);
+        }
+        switch (this.tempParams.returnCriteria) {
+            case RailSearchCriteria.Depart:
+                query.returnArrivalDateTime = null;
+                break;
+            case RailSearchCriteria.Arrive:
+                query.returnDepartureDateTime = null;
+                break;
+            default:
+                console.warn(`+++ Unknown Criteria: ${this.tempParams.returnCriteria} +++`);
+        }
+        switch (this.tempParams.chosenSearchType) {
+            case RailJourneyType.SingleJourney:
+            case RailJourneyType.OpenReturnJourney:
+                query.returnDepartureDateTime = null;
+                query.returnArrivalDateTime = null;
+                break;
+        }
+        return this.helpers.removeNulls(query);
+    }
+    getRailStationById(id) {
+        if (id) {
+            return this.getRailStationFetcher.fetchList({ id }).pipe(take(1));
+        }
+        else {
+            return of();
+        }
+    }
+    getCriteria(departureDateTime, arrivalDateTime) {
+        if (departureDateTime) {
+            return RailSearchCriteria.Depart;
+        }
+        else if (arrivalDateTime) {
+            return RailSearchCriteria.Arrive;
+        }
+        {
+            return null;
+        }
+    }
+    createTicketGroups(results) {
+        let tickets = {};
+        let ticketId = '';
+        this._canCombine = {};
+        let ticketGroupsOutbound = this.setTicketsGroups(results[0].outbound);
+        let ticketGroupsReturn = this.setTicketsGroups(results[0].return);
+        ticketGroupsOutbound = this.sortTicketPrices(ticketGroupsOutbound);
+        ticketGroupsReturn = this.sortTicketPrices(ticketGroupsReturn);
+        Object.keys(ticketGroupsOutbound).map((key) => {
+            ticketGroupsOutbound[key].map((tkt) => {
+                ticketId = `${tkt.type}${tkt.singleOrReturn}`;
+                const identifier = tkt.identifiers.journeyIdentifier;
+                const identifierObj = {};
+                identifierObj[identifier] = {
+                    price: tkt.price,
+                    isChild: false,
+                    fareIdentifier: tkt.identifiers.fareIdentifier,
+                    availableSeats: tkt.availableSeats
+                };
+                if (tickets[key]) {
+                    this.updateCanCombine(tkt);
+                    identifierObj[tkt.identifiers.journeyIdentifier].isChild = false;
+                    if (tickets[tkt.type].header.price === tkt.price) {
+                        tickets[tkt.type].resultIndifiers.push(identifier);
+                        tickets[tkt.type].resultIndifiersPrices = Object.assign(Object.assign({}, tickets[tkt.type].resultIndifiersPrices), identifierObj);
+                    }
+                    else if (tkt.price) {
+                        // add identifier and price even if it is a child
+                        if (!tickets[tkt.type].resultIndifiers.includes(identifier)) {
+                            tickets[tkt.type].resultIndifiers.push(identifier);
+                            tickets[tkt.type].resultIndifiersPrices = Object.assign(Object.assign({}, tickets[tkt.type].resultIndifiersPrices), identifierObj);
+                        }
+                        identifierObj[identifier].isChild = true;
+                        const childTicket = {
+                            header: tkt,
+                            children: [],
+                            open: false,
+                            direction: RailDirection.Outbound,
+                            resultIndifiers: [identifier],
+                            resultIndifiersPrices: identifierObj,
+                            child: true,
+                            ticketId,
+                            selectedIndicies: [],
+                            disabledIndicies: [],
+                            showLimitedSeats: false
+                        };
+                        tickets[tkt.type].children.push(childTicket);
+                    }
+                }
+                else {
+                    this._canCombine[tkt.type] = {};
+                    this.updateCanCombine(tkt);
+                    tickets[tkt.type] = {
+                        header: tkt,
+                        children: [],
+                        open: false,
+                        direction: RailDirection.Outbound,
+                        resultIndifiers: [identifier],
+                        resultIndifiersPrices: identifierObj,
+                        child: false,
+                        ticketId,
+                        selectedIndicies: [],
+                        disabledIndicies: [],
+                        showLimitedSeats: false
+                    };
+                }
+            });
+        });
+        Object.keys(ticketGroupsReturn).map((key) => {
+            ticketGroupsReturn[key].map((tkt) => {
+                ticketId = `${tkt.type}${tkt.singleOrReturn}`;
+                const identifier = tkt.identifiers.journeyIdentifier;
+                const identifierObj = {};
+                identifierObj[identifier] = {
+                    price: tkt.price,
+                    isChild: true,
+                    fareIdentifier: tkt.identifiers.fareIdentifier,
+                    availableSeats: tkt.availableSeats
+                };
+                if (tickets[tkt.type] &&
+                    tkt.price &&
+                    tkt.price !== tickets[tkt.type].header.price) {
+                    this.updateCanCombine(tkt);
+                    identifierObj[identifier].isChild = true;
+                    const childTicket = {
+                        header: tkt,
+                        children: [],
+                        open: false,
+                        direction: RailDirection.Inbound,
+                        resultIndifiers: [identifier],
+                        resultIndifiersPrices: identifierObj,
+                        child: true,
+                        ticketId,
+                        selectedIndicies: [],
+                        disabledIndicies: [],
+                        showLimitedSeats: false
+                    };
+                    tickets[tkt.type].children.push(childTicket);
+                }
+                else if (!tickets[tkt.type]) {
+                    this.updateCanCombine(tkt);
+                    tickets[tkt.type] = {
+                        header: tkt,
+                        children: [],
+                        open: false,
+                        direction: RailDirection.Inbound,
+                        resultIndifiers: [identifier],
+                        resultIndifiersPrices: identifierObj,
+                        child: false,
+                        ticketId,
+                        selectedIndicies: [],
+                        disabledIndicies: [],
+                        showLimitedSeats: false
+                    };
+                }
+                else if (!tkt.price || tkt.price === tickets[tkt.type].header.price) {
+                    this.updateCanCombine(tkt);
+                    tickets[tkt.type].resultIndifiers.push(identifier);
+                    identifierObj[identifier].isChild = false;
+                    tickets[tkt.type].resultIndifiersPrices = Object.assign(Object.assign({}, tickets[tkt.type].resultIndifiersPrices), identifierObj);
+                }
+            });
+        });
+        let combineTickets = Object.assign({}, tickets);
+        tickets = this.combineChildTickets(combineTickets);
+        // console.log('groups: ', tickets);
+        // console.log('Can Combine: ', this._canCombine);
+        return tickets;
+    }
+    combineChildTickets(tickets) {
+        const values = Object.values(tickets);
+        for (let i = 0; i < values.length; i++) {
+            const childObject = {};
+            for (let j = 0; j < values[i].children.length; j++) {
+                const child = values[i].children[j];
+                const fareIdentifier = child.header.identifiers.fareIdentifier;
+                if (childObject[fareIdentifier]) {
+                    childObject[fareIdentifier].resultIndifiers.push(child.resultIndifiers[0]);
+                    childObject[fareIdentifier].resultIndifiersPrices = Object.assign(Object.assign({}, childObject[fareIdentifier].resultIndifiersPrices), child.resultIndifiersPrices);
+                }
+                else {
+                    childObject[fareIdentifier] = child;
+                }
+            }
+            // console.log(childObject);
+            // console.log(values[i]['header']['type']);
+            tickets[values[i].header.type].children = Object.values(childObject);
+        }
+        tickets = this.sortTicketChildrenPrices(tickets);
+        return tickets;
+    }
+    setTicketsGroups(results) {
+        let ticketGroups = {};
+        results.forEach((out) => {
+            out.providers.forEach((prov) => {
+                prov.ticketOptions.forEach((tkt) => {
+                    ticketGroups[tkt.type]
+                        ? ticketGroups[tkt.type].push(tkt)
+                        : (ticketGroups[tkt.type] = [tkt]);
+                });
+            });
+        });
+        return ticketGroups;
+    }
+    updateFromPreviousSearches(previousItems) { }
+    updateCanCombine(tkt) {
+        (tkt.identifiers.allowedWith || []).forEach((allowed) => {
+            if (!this._canCombine[tkt.type][allowed.journeyIdentifier]) {
+                this._canCombine[tkt.type][allowed.journeyIdentifier] = [
+                    allowed.fareIdentifier
+                ];
+            }
+            else {
+                this._canCombine[tkt.type][allowed.journeyIdentifier].push(allowed.fareIdentifier);
+            }
+        });
+    }
+    toggleTicketSelect(ticket, way, timeSlotId, ticketId, fareIdentifier, ticketsGroups) {
+        console.log(ticket);
+        if (!ticket) {
+            return;
+        }
+        this._chosenTicketGroup = ticket;
+        const keys = Object.keys(ticketsGroups);
+        let selectedTicket = null;
+        let departsTicket = [];
+        let returnTicket = [];
+        let isUnselected = false;
+        keys.forEach((key) => {
+            let group = ticketsGroups[key];
+            if (group.ticketId === ticketId &&
+                group.selectedIndicies.includes(timeSlotId)) {
+                if (way === 'departs') {
+                    group.selectedIndicies = [];
+                    departsTicket = [];
+                    returnTicket = [];
+                    this._chosenInboundTicket = null;
+                    this._chosenInboundJourney = null;
+                    this._chosenTicketGroup = null;
+                    group.children.forEach((child) => {
+                        child.selectedIndicies = [];
+                    });
+                }
+                else {
+                    group.selectedIndicies = group.selectedIndicies.filter((Indicies) => Indicies !== timeSlotId);
+                    returnTicket = returnTicket.filter((Indicies) => Indicies !== group.header);
+                }
+            }
+            else {
+                if (group.ticketId === ticketId &&
+                    group.header.identifiers.fareIdentifier === fareIdentifier &&
+                    way === 'departs') {
+                    group = this.clearUnneededTickets(way, group, timeSlotId);
+                    group.selectedIndicies.push(timeSlotId);
+                    way === 'departs'
+                        ? departsTicket.push(group.header)
+                        : returnTicket.push(group.header);
+                    selectedTicket = group.header;
+                }
+                else {
+                    // may have to modify this for dual singles
+                    if (way === 'departs') {
+                        group.selectedIndicies = [];
+                    }
+                    else if (ticketId.includes(group.header.type)) {
+                        selectedTicket = group.header;
+                    }
+                }
+                group.children.forEach((child) => {
+                    if (child.selectedIndicies.includes(timeSlotId)) {
+                        if (way === 'departs') {
+                            child.selectedIndicies = [];
+                            departsTicket = [];
+                            returnTicket = [];
+                            this._chosenInboundTicket = null;
+                            this._chosenInboundJourney = null;
+                            isUnselected = true;
+                        }
+                        else {
+                            child.selectedIndicies = child.selectedIndicies.filter((Indicies) => Indicies !== timeSlotId);
+                            returnTicket = returnTicket.filter((Indicies) => Indicies !== group.header);
+                        }
+                    }
+                    else {
+                        if (child.ticketId === ticketId &&
+                            child.header.identifiers.fareIdentifier === fareIdentifier) {
+                            if ((way === 'departs' &&
+                                child.direction !== RailDirection.Inbound) ||
+                                (way !== 'departs' && child.direction === RailDirection.Inbound)) {
+                                child = this.clearUnneededTickets(way, child, timeSlotId);
+                                child.selectedIndicies.push(timeSlotId);
+                                way === 'departs'
+                                    ? departsTicket.push(child.header)
+                                    : returnTicket.push(child.header);
+                                selectedTicket = child.header;
+                            }
+                            else if (isUnselected) {
+                                child.selectedIndicies = [];
+                            }
+                        }
+                        else {
+                            child.selectedIndicies = [];
+                        }
+                    }
+                });
+            }
+        });
+        // now we need to mark tickets as disabled if they are returns that do not match the selected return
+        // or on overlapping times
+        if (way === 'departs') {
+            this._chosenOutboundTicket = this.helpers.clone(selectedTicket);
+            // now go over the full results and find the matching timeslot
+            departsTicket.length
+                ? (this._chosenOutboundJourney = this.results.value[0].outbound.find((out) => {
+                    return out.identifiers.journeyIdentifier === timeSlotId;
+                }))
+                : (this._chosenOutboundJourney = null);
+            if (this._chosenInboundTicket &&
+                this._chosenOutboundTicket.singleOrReturn ===
+                    RailTicketOptionType.Return &&
+                this._chosenOutboundTicket.identifiers.fareIdentifier !==
+                    this._chosenInboundTicket.identifiers.fareIdentifier) {
+                console.warn('+++ Cannot combine fares, clearing inbound... +++');
+                this._chosenInboundTicket = null;
+                this._chosenInboundJourney = null;
+            }
+        }
+        else if (way === 'returns') {
+            this._chosenInboundTicket = this.helpers.clone(selectedTicket);
+            this._chosenInboundTicket
+                ? (this._chosenInboundJourney = this.results.value[0].return.find((inT) => {
+                    return inT.identifiers.journeyIdentifier === timeSlotId;
+                }))
+                : (this._chosenInboundJourney = null);
+        }
+        return ticketsGroups;
+    }
+    /**
+     * @description - determine if a fare can be combined with what we currently have selected
+     */
+    canCombine(journeyIdentifier, fareIdentifier) {
+        var _a;
+        // may have to modify this for dual singles later on
+        try {
+            if (this._chosenOutboundTicket &&
+                this._chosenOutboundTicket.singleOrReturn ===
+                    RailTicketOptionType.Return &&
+                Number(journeyIdentifier) > 5) {
+                // greater than 5 only as we are not going to restrict outbounds
+                if (((_a = this._canCombine[this._chosenOutboundTicket.type][Number(journeyIdentifier)]) === null || _a === void 0 ? void 0 : _a.includes(fareIdentifier)) &&
+                    this._chosenOutboundTicket.identifiers.fareIdentifier ===
+                        fareIdentifier) {
+                    return true;
+                }
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('+++ Error combining rail fares: ', error, ' +++');
+        }
+        return false;
+    }
+    clearUnneededTickets(way, group, timeSlotId) {
+        if (way === 'returns') {
+            group.selectedIndicies = group.selectedIndicies.filter((indicie) => {
+                return Number(indicie) <= 5 || indicie === timeSlotId;
+            });
+        }
+        else {
+            group.selectedIndicies = group.selectedIndicies.filter((indicie) => {
+                return Number(indicie) > 5 || indicie === timeSlotId;
+            });
+        }
+        return group;
+    }
+    getRailStation(code, isLoading) {
+        if (code.length === 3) {
+            isLoading === null || isLoading === void 0 ? void 0 : isLoading.next(true);
+            return this.getRailStationFetcher.fetchList({ code }).pipe(tap(() => isLoading === null || isLoading === void 0 ? void 0 : isLoading.next(false)), take(1));
+        }
+        else {
+            return of();
+        }
+    }
+    getSelectedRailTicketOption(railJourneyOption, railTicketGroup, providerIndex) {
+        return railJourneyOption.providers[providerIndex].ticketOptions.find((ticketOption) => ticketOption.type === railTicketGroup.header.type &&
+            (ticketOption.price === railTicketGroup.header.price ||
+                ticketOption.identifiers.fareIdentifier ===
+                    railTicketGroup.header.identifiers.fareIdentifier));
+    }
+    getLegsFromRailJourneyOption(railJourneyOption) {
+        let legs = [];
+        if (railJourneyOption === null || railJourneyOption === void 0 ? void 0 : railJourneyOption.segments.length) {
+            legs = railJourneyOption.segments.map((segment) => {
+                return {
+                    operator: segment.operator,
+                    departureDateTime: segment.departDateTime,
+                    departureStationName: segment.depart,
+                    arrivalDateTime: segment.arriveDateTime,
+                    arrivalStationName: segment.arrive
+                };
+            });
+        }
+        return legs;
+    }
+    addSingleJourneyToBasket(serviceId, railQuery, railJourneyOption, railTicketGroup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let outTicketExtras;
+            // if ticketExtras exists create TicketExtrasObject and added it to the basket
+            if (railJourneyOption.ticketExtras) {
+                outTicketExtras = this.createTicketExtrasObject(railJourneyOption.ticketExtras[0]);
+            }
+            if (railJourneyOption.unsellable) {
+                return Promise.resolve(false);
+            }
+            const intBasket = yield this.basketService.getDefaultBasket();
+            const basket = intBasket === null || intBasket === void 0 ? void 0 : intBasket.subject.value;
+            if (basket) {
+                const selectedRailTicketOption = this.getSelectedRailTicketOption(railJourneyOption, railTicketGroup, 0);
+                const legs = this.getLegsFromRailJourneyOption(railJourneyOption);
+                const ticketQueueList = selectedRailTicketOption.ticketQueueList.map((ticketQueueList1) => {
+                    return {
+                        id: ticketQueueList1.id,
+                        name: ticketQueueList1.name,
+                        type: ticketQueueList1.type
+                    };
+                });
+                const basketItem = {
+                    basket: basket.id,
+                    service: serviceId,
+                    detail: {
+                        accountsList: selectedRailTicketOption.accountsList.map((account) => {
+                            return { id: account.id, description: account.description };
+                        }),
+                        outwardDetail: {
+                            arrivalDateTime: railJourneyOption.arriveDateTime,
+                            arrivalStationName: railJourneyOption.to,
+                            departureDateTime: railJourneyOption.departDateTime,
+                            departureStationName: railJourneyOption.from,
+                            supplierTickets: [
+                                {
+                                    supplierName: railJourneyOption.providers[0].name,
+                                    ticketDescription: selectedRailTicketOption.type,
+                                    price: selectedRailTicketOption.price,
+                                    legs
+                                }
+                            ]
+                        },
+                        transactionIdentifier: railJourneyOption.identifiers.transactionIdentifier,
+                        outbound: {
+                            fareIdentifiers: [
+                                selectedRailTicketOption.identifiers.fareIdentifier
+                            ],
+                            journeyIdentifier: selectedRailTicketOption.identifiers.journeyIdentifier
+                        },
+                        ticketQueueList
+                    },
+                    adults: railQuery.adults,
+                    price: selectedRailTicketOption.price,
+                    currency: selectedRailTicketOption.currency,
+                    searchQuery: railQuery,
+                    co2PerItem: railJourneyOption.co2PerItem,
+                    co2PerPassenger: railJourneyOption.co2PerPassenger,
+                    outboundDate: railJourneyOption.departDateTime
+                };
+                // if outTicketExtras exists add the object to basketItem
+                if (outTicketExtras) {
+                    basketItem.detail.outbound.ticketExtras = outTicketExtras;
+                }
+                return this.basketService.addToBasket(basketItem, intBasket, this.searchService, this.travellers);
+            }
+            return Promise.resolve(false);
+        });
+    }
+    addReturnJourneyToBasket(serviceId, railQuery, outbound, inbound, railTicketGroup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (outbound.unsellable) {
+                return Promise.resolve(false);
+            }
+            let inTicketExtras;
+            let outTicketExtras;
+            // if ticketExtras exists create TicketExtrasObject and added it to the basket
+            if (inbound.ticketExtras) {
+                inTicketExtras = this.createTicketExtrasObject(inbound.ticketExtras[0]);
+            }
+            if (outbound.ticketExtras) {
+                outTicketExtras = this.createTicketExtrasObject(outbound.ticketExtras[0]);
+            }
+            const intBasket = yield this.basketService.getDefaultBasket();
+            const basket = intBasket === null || intBasket === void 0 ? void 0 : intBasket.subject.value;
+            if (basket) {
+                const selectedRailTicketOption = this.getSelectedRailTicketOption(outbound, railTicketGroup, 0);
+                const selectedInboundRailTicketOption = this.getSelectedRailTicketOption(inbound, railTicketGroup, 0);
+                const outboundLegs = this.getLegsFromRailJourneyOption(outbound);
+                const inboundLegs = this.getLegsFromRailJourneyOption(inbound);
+                const ticketQueueList = selectedRailTicketOption.ticketQueueList.map((ticketQueueList1) => {
+                    return {
+                        id: ticketQueueList1.id,
+                        name: ticketQueueList1.name,
+                        type: ticketQueueList1.type
+                    };
+                });
+                const basketItem = {
+                    basket: basket.id,
+                    service: serviceId,
+                    detail: {
+                        accountsList: selectedRailTicketOption.accountsList.map((account) => {
+                            return { id: account.id, description: account.description };
+                        }),
+                        outwardDetail: {
+                            arrivalDateTime: outbound.arriveDateTime,
+                            arrivalStationName: outbound.to,
+                            departureDateTime: outbound.departDateTime,
+                            departureStationName: outbound.from,
+                            supplierTickets: [
+                                {
+                                    supplierName: outbound.providers[0].name,
+                                    ticketDescription: selectedRailTicketOption.type,
+                                    price: selectedRailTicketOption.price,
+                                    legs: outboundLegs
+                                }
+                            ]
+                        },
+                        inwardDetail: {
+                            arrivalDateTime: inbound.arriveDateTime,
+                            arrivalStationName: inbound.to,
+                            departureDateTime: inbound.departDateTime,
+                            departureStationName: inbound.from,
+                            supplierTickets: [
+                                {
+                                    supplierName: inbound.providers[0].name,
+                                    ticketDescription: selectedRailTicketOption.type,
+                                    legs: inboundLegs
+                                }
+                            ]
+                        },
+                        transactionIdentifier: outbound.identifiers.transactionIdentifier,
+                        outbound: {
+                            fareIdentifiers: [
+                                selectedRailTicketOption.identifiers.fareIdentifier
+                            ],
+                            journeyIdentifier: selectedRailTicketOption.identifiers.journeyIdentifier
+                        },
+                        ticketQueueList,
+                        return: {
+                            fareIdentifiers: [
+                                selectedInboundRailTicketOption.identifiers.fareIdentifier
+                            ],
+                            journeyIdentifier: selectedInboundRailTicketOption.identifiers.journeyIdentifier
+                        }
+                    },
+                    adults: railQuery.adults,
+                    price: railTicketGroup.header.price,
+                    currency: selectedRailTicketOption.currency,
+                    searchQuery: railQuery,
+                    co2PerItem: outbound.co2PerItem,
+                    co2PerPassenger: outbound.co2PerPassenger,
+                    outboundDate: outbound.arriveDateTime,
+                    inboundDate: inbound.arriveDateTime
+                };
+                // if inTicketExtras or outTicketExtras exists add the object to basketItem
+                if (inTicketExtras) {
+                    basketItem.detail.return.ticketExtras = inTicketExtras;
+                }
+                if (outTicketExtras) {
+                    basketItem.detail.outbound.ticketExtras = outTicketExtras;
+                }
+                return this.basketService.addToBasket(basketItem, intBasket, this.searchService, this.travellers);
+            }
+            return Promise.resolve(false);
+        });
+    }
+    createTicketExtrasObject(railTicketExtra) {
+        return [{
+                type: railTicketExtra.description,
+                location: railTicketExtra.location,
+                date: railTicketExtra.date
+            }];
+    }
+    sortTicketPrices(tickets) {
+        const sortTicketPrices = Object.assign({}, tickets);
+        Object.keys(sortTicketPrices).map((key) => {
+            sortTicketPrices[key].sort((a, b) => {
+                const priceA = a.price;
+                const priceB = b.price;
+                return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;
+            });
+        });
+        return sortTicketPrices;
+    }
+    sortTicketChildrenPrices(tickets) {
+        const sortTicketPrices = Object.assign({}, tickets);
+        Object.keys(sortTicketPrices).map((key) => {
+            sortTicketPrices[key].children.sort((a, b) => {
+                const priceA = a.header.price;
+                const priceB = b.header.price;
+                return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;
+            });
+        });
+        return sortTicketPrices;
+    }
+    updateLowestPrice(results) {
+        if (!results.length)
+            return null;
+        let currency;
+        try {
+            currency = results[0].outbound[0].providers[0].ticketOptions[0].currency;
+        }
+        catch (error) {
+            currency = 'GBP';
+        }
+        const price = this.findCheapestTicket(results);
+        return {
+            amount: price,
+            currencyCode: currency
+        };
+    }
+    findCheapestTicket(results) {
+        this._cheapestFirst = null;
+        this._cheapestStandard = null;
+        if (!results.length)
+            return null;
+        let cheapestArr = [];
+        results.map((result) => {
+            result.outbound.map((out) => {
+                out.providers.map((tkt) => {
+                    let cheapestTicket = tkt.ticketOptions[0].price;
+                    tkt.ticketOptions.map((tktOption) => {
+                        var _a, _b;
+                        let tktPrice = tktOption.price;
+                        let tktClass = tktOption.class;
+                        if (tktClass === 'First' &&
+                            (((_a = this._cheapestFirst) === null || _a === void 0 ? void 0 : _a.price) > tktPrice || !this._cheapestFirst)) {
+                            this._cheapestFirst = tktOption;
+                        }
+                        else if (tktClass === 'Standard' &&
+                            (((_b = this._cheapestStandard) === null || _b === void 0 ? void 0 : _b.price) > tktPrice ||
+                                !this._cheapestStandard)) {
+                            this._cheapestStandard = tktOption;
+                        }
+                        if (tktPrice === cheapestTicket) {
+                            cheapestArr.push(cheapestTicket);
+                        }
+                    });
+                });
+            });
+        });
+        return Math.min(...cheapestArr);
+    }
+    calculateTimeDifferenceInMins(railJourney) {
+        return this.helpers
+            .getTimeDifference(railJourney.arriveDateTime, railJourney.departDateTime)
+            .toString();
+    }
+    /**
+     * @description - determine if a ticket is an eTicket
+     * @param ticket - the ticket we want to to check
+     * @returns - boolean
+     */
+    ticketIsAnETicket(ticket) {
+        let foundETicket = null;
+        foundETicket = ticket.ticketQueueList.find((queueListItem) => {
+            return queueListItem.type === 'eTicket';
+        });
+        return foundETicket ? true : null;
+    }
+    /**
+     * @description - clear all of our chosen tickets/other rail stuff, call this when kicking off a new search
+     */
+    clearChosenTickets() {
+        this._chosenInboundTicket = null;
+        this._chosenOutboundTicket = null;
+        this._chosenInboundJourney = null;
+        this._chosenOutboundJourney = null;
+        this._chosenTicketGroup = null;
+    }
+}
+RailEnterpriseSearch.STORAGE_SESSION_PARAMS = 'search_rail';
+RailEnterpriseSearch.STORAGE_SESSION_RESULTS = 'rail_results';
+RailEnterpriseSearch.PASSING_POINT = 'Passing';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rail-enterprise-search.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/base/src/lib/vendor/classes/rail-enterprise-search.ts"],"names":[],"mappings":";AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,EAAE,EAA+B,aAAa,EAAE,MAAM,MAAM,CAAC;AACtE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AASzD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAQtD,OAAO,EAIL,SAAS,EAGT,eAAe,EASf,WAAW,EAEZ,MAAM,wBAAwB,CAAC;AAwBhC,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,6CAAuB,CAAA;IACvB,8CAAwB,CAAA;AAC1B,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B;AAED,MAAM,CAAN,IAAY,oBAGX;AAHD,WAAY,oBAAoB;IAC9B,yCAAiB,CAAA;IACjB,yCAAiB,CAAA;AACnB,CAAC,EAHW,oBAAoB,KAApB,oBAAoB,QAG/B;AAED,MAAM,OAAO,oBAIX,SAAQ,oBAIP;IAseD,YACU,WAAoC,EACpC,qBAAuD,EACvD,OAA2B,EAC3B,aAA+C,EACvD,cAAkC,EAC1B,aAA+C;QAEvD,KAAK,CAAC,cAAc,CAAC,CAAC;QAPd,gBAAW,GAAX,WAAW,CAAyB;QACpC,0BAAqB,GAArB,qBAAqB,CAAkC;QACvD,YAAO,GAAP,OAAO,CAAoB;QAC3B,kBAAa,GAAb,aAAa,CAAkC;QAE/C,kBAAa,GAAb,aAAa,CAAkC;QApe/C,uBAAkB,GAAG,oBAAoB,CAAC,uBAAuB,CAAC;QAErE,gBAAW,GAAG;YACnB,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,eAAe,CAAC,aAAa,EAAE;YAC3D,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,CAAC,aAAa,EAAE;YAC5D,wEAAwE;YACxE,yEAAyE;SAC1E,CAAC;QAEK,eAAU,GAAG;YAClB,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,GAAG,EAAE;YACxC,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,CAAC,QAAQ,EAAE;YAClD,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE;SAC7C,CAAC;QAEK,2BAAsB,GAAkC;YAC7D,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,4BAA4B,EAAE;YACrD,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,0BAA0B,EAAE;YACjD,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,0BAA0B,EAAE;YACjD,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,4BAA4B,EAAE;YACrD,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,0BAA0B,EAAE;YACjD,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,0BAA0B,EAAE;YACjD,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,oBAAoB,EAAE;YAC1C,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,oBAAoB,EAAE;YAC1C,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,6BAA6B,EAAE;YACnD,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,6BAA6B,EAAE;SACpD,CAAC;QAEK,gCAA2B,GAE9B;YACF,OAAO,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YACnC,OAAO,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YACnC,GAAG,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YAC/B,GAAG,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YAC/B,GAAG,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YAC/B,GAAG,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YAC/B,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YAC9B,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YAC9B,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;YAC9B,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;SAC/B,CAAC;QAEK,iBAAY,GAAG,CAAC,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAEtE,gBAAW,GAAG;YACnB,EAAE,OAAO,EAAE,wBAAwB,EAAE,KAAK,EAAE,KAAK,EAAE;YACnD,EAAE,OAAO,EAAE,qBAAqB,EAAE,KAAK,EAAE,KAAK,EAAE;YAChD,EAAE,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,KAAK,EAAE;YAC5C,EAAE,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,KAAK,EAAE;YAC5C,EAAE,OAAO,EAAE,wBAAwB,EAAE,KAAK,EAAE,KAAK,EAAE;SACpD,CAAC;QAEF,iCAAiC;QACjC,8BAA8B;QAC9B,0BAA0B;QAC1B,0BAA0B;QAC1B,gCAAgC;QACzB,mCAA8B,GAAG,IAAI,CAAC;QACtC,SAAI,GAAgB,WAAW,CAAC,IAAI,CAAC;QACrC,oBAAe,GAAkB;YACtC,IAAI,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE;YACrB,KAAK,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC;YAC3B,GAAG,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE;SACrB,CAAC;QACK,mBAAc,GAAkB;YACrC,IAAI,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE;YACrB,KAAK,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC;YAC3B,GAAG,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE;SACrB,CAAC;QACK,YAAO,GAAkB;YAC9B,0DAA0D;YAC1D,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE;YACrC,KAAK,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE;YACvC,GAAG,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE;SACrC,CAAC;QA6OF,+CAA+C;QACvC,mBAAc,GAAkB,IAAI,CAAC;QAWrC,mBAAc,GAAW,IAAI,CAAC;QAU9B,iBAAY,GAAkB,IAAI,CAAC;QAWnC,iBAAY,GAAW,IAAI,CAAC;QA4H5B,sBAAiB,GAAqB,IAAI,CAAC;QAI3C,mBAAc,GAAqB,IAAI,CAAC;QAe9C,MAAM,IAAI,GAIN,cAAc,CAAC,cAAc,CAC/B,oBAAoB,CAAC,sBAAsB,CAC5C,IAAI;YACH,KAAK,EAAE,EAAE;YACT,UAAU,EAAE,EAAoB;YAChC,kBAAkB,EAAE,EAAoB;SACzC,CAAC;QAEF,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QACzE,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,kBAAkB,CAAC;QAEnD,IAAI,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,EAAE;YACzE,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC;SACnE;QAED,IAAI,aAAa,CAAC,8BAA8B,EAAE,EAAE;YAClD,aAAa,CAAC,oBAAoB,CAAC,SAAS,CAC1C,CAAC,UAAuB,EAAE,EAAE;gBAC1B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;gBAC7B,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,CACrD,UAAU,EACV,WAAW,CAAC,IAAI,CACjB,CAAC;gBACF,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC;gBAC3D,IAAI,CAAC,UAAU,CAAC,YAAY,GAAG,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC;gBAC/D,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;gBAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,CAAC,CACF,CAAC;SACH;QACD,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,MAAM,OAAO,GACX,cAAc,CAAC,oBAAoB,CACjC,IAAI,CAAC,kBAAkB,CACxB,IAAI,EAAE,CAAC;QACV,yCAAyC;QACzC,mCAAmC;QACnC,IAAI;QACJ,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC5D,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;IACnC,CAAC;IA5bD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAED,IAAI,gBAAgB;QAClB,IAAI,IAAI,CAAC,qBAAqB,EAAE;YAC9B,IAAI,IAAI,CAAC,oBAAoB,EAAE;gBAC7B,wCAAwC;gBACxC,IACE,IAAI,CAAC,qBAAqB,CAAC,cAAc;oBACvC,oBAAoB,CAAC,MAAM;oBAC7B,IAAI,CAAC,oBAAoB,CAAC,cAAc;wBACtC,oBAAoB,CAAC,MAAM,EAC7B;oBACA,uCAAuC;oBACvC,OAAO,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC;iBACzC;gBACD,OAAO,CACL,IAAI,CAAC,qBAAqB,CAAC,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,KAAK,CACnE,CAAC;aACH;YAED,OAAO,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC;SACzC;QAED,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,aAAa;QACf,OAAO;YACL,QAAQ,EAAE,IAAI,CAAC,qBAAqB;YACpC,OAAO,EAAE,IAAI,CAAC,oBAAoB;SACnC,CAAC;IACJ,CAAC;IAED,IAAI,qBAAqB;QACvB,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACrC,CAAC;IAED,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;IACpC,CAAC;IAED,IAAI,UAAU,CAAC,MAAe;QAC5B,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,MAAM,CAAC;QAEpC,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,UAAU,CAAC,gBAAgB,GAAG,eAAe,CAAC,iBAAiB,CAAC;SACtE;QACD,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC;IAC1C,CAAC;IAED,IAAI,gBAAgB,CAAC,OAAwB;QAC3C,IAAI,CAAC,UAAU,CAAC,gBAAgB,GAAG,OAAO,CAAC;QAC3C,IAAI,OAAO,KAAK,eAAe,CAAC,aAAa,EAAE;YAC7C,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;SACzB;QACD,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;IACpC,CAAC;IAED,IAAI,UAAU,CAAC,MAAc;QAC3B,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,MAAM,CAAC;QACpC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;IACtC,CAAC;IAED,IAAI,YAAY,CAAC,QAAgB;QAC/B,IAAI,CAAC,UAAU,CAAC,YAAY,GAAG,QAAQ,CAAC;QACxC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;IACtC,CAAC;IAED,IAAI,YAAY,CAAC,EAAO;;QACtB,IAAI,CAAC,UAAU,CAAC,YAAY,GAAG,EAAE,CAAC;QAElC,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;QACxB,UAAI,EAAE,aAAF,EAAE,uBAAF,EAAE,CAAE,WAAW,0CAAE,EAAE,EAAE;YACvB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC;SACxC;QAED,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;IACxC,CAAC;IAED,IAAI,cAAc,CAAC,EAAO;;QACxB,IAAI,CAAC,UAAU,CAAC,cAAc,GAAG,EAAE,CAAC;QACpC,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,UAAI,EAAE,aAAF,EAAE,uBAAF,EAAE,CAAE,WAAW,0CAAE,EAAE,EAAE;YACvB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC;SAC1C;QAED,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC;IAC3C,CAAC;IAED,IAAI,eAAe,CAAC,QAAmB;QACrC,IAAI,CAAC,UAAU,CAAC,iBAAiB,GAAG,QAAQ,CAAC;IAC/C,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC;IAC3C,CAAC;IAED,IAAI,iBAAiB,CAAC,MAAiB;QACrC,IAAI,CAAC,UAAU,CAAC,iBAAiB,GAAG,MAAM,CAAC;QAC3C,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;IACnC,CAAC;IAED,IAAI,SAAS,CAAC,KAAc;QAC1B,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,KAAK,CAAC;QAClC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;IAC7B,CAAC;IAED,IAAI,GAAG,CAAC,GAAY;QAClB,IAAI,CAAC,UAAU,CAAC,GAAG,GAAG,GAAG,CAAC;QAC1B,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;IACrC,CAAC;IAED,IAAI,WAAW,CAAC,WAAgB;;QAC9B,IAAI,CAAC,UAAU,CAAC,WAAW,GAAG,WAAW,CAAC;QAE1C,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,UAAI,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,WAAW,0CAAE,EAAE,EAAE;YAChC,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,WAAW,CAAC,EAAE,CAAC;SAChD;QAED,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC;IAC1C,CAAC;IAED,IAAI,gBAAgB,CAAC,WAA0B;QAC7C,IAAI,CAAC,UAAU,CAAC,gBAAgB,GAAG,WAAW,CAAC;QAC/C,IAAI,WAAW,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE;YACxC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;YAC/D,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;gBACtD,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;gBACpC,CAAC,CAAC,MAAM,CAAC;SACZ;QAED,IAAI,CAAC,cAAc,GAAG;YACpB,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE;YACxB,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC;YAC9B,GAAG,EAAE,WAAW,CAAC,IAAI,EAAE;SACxB,CAAC;QAEF,IACE,IAAI,CAAC,gBAAgB;YACrB,IAAI,CAAC,eAAe;YACpB,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,EACnD;YACA,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe;iBACxC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC;iBAC/B,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC;iBACjC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;SACpC;QAED,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC;IAC1C,CAAC;IAED,IAAI,gBAAgB,CAAC,OAA2B;QAC9C,4DAA4D;QAC5D,IAAI,CAAC,UAAU,CAAC,gBAAgB,GAAG,OAAO,CAAC;QAE3C,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;IACzC,CAAC;IAED,IAAI,eAAe,CAAC,WAA0B;QAC5C,IAAI,CAAC,UAAU,CAAC,eAAe,GAAG,WAAW,CAAC;QAC9C,IAAI,WAAW,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE;YACxC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;YAC7D,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;gBACpD,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;gBACpC,CAAC,CAAC,MAAM,CAAC;SACZ;QACD,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAKD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,IAAI,aAAa,CAAC,KAAoB;QACpC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAGD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,IAAI,aAAa,CAAC,KAAa;QAC7B,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAID,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,IAAI,WAAW,CAAC,KAAoB;QAClC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAGD,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,IAAI,WAAW,CAAC,KAAa;QAC3B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;IACxC,CAAC;IAED,IAAI,cAAc,CAAC,OAA2B;QAC5C,IAAI,CAAC,UAAU,CAAC,cAAc,GAAG,OAAO,CAAC;QACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;IACtC,CAAC;IAED,IAAI,YAAY,CAAC,SAAkB;QACjC,IAAI,CAAC,UAAU,CAAC,YAAY,GAAG,SAAS,CAAC;QACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAAC;IAC9C,CAAC;IAED,IAAI,oBAAoB,CAAC,MAAe;QACtC,IAAI,CAAC,UAAU,CAAC,oBAAoB,GAAG,MAAM,CAAC;QAC9C,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC;IAC3C,CAAC;IAED,IAAI,iBAAiB,CAAC,WAAoB;QACxC,IAAI,CAAC,UAAU,CAAC,iBAAiB,GAAG,WAAW,CAAC;QAChD,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;IACxC,CAAC;IAED,IAAI,cAAc,CAAC,OAAgB;QACjC,IAAI,CAAC,UAAU,CAAC,cAAc,GAAG,OAAO,CAAC;IAC3C,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;IACnC,CAAC;IAED,IAAI,SAAS,CAAC,KAAmC;QAC/C,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,KAAK,CAAC;IACpC,CAAC;IAED,IAAW,SAAS;QAClB,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU;gBACf,KAAK,CAAC,EAAE,CAAC;qBACN,IAAI,CAAC,CAAC,CAAC;qBACP,GAAG,CAAC,CAAC,CAAC,EAAE,KAAa,EAAE,EAAE;oBACxB,OAAO;wBACL,KAAK,EACH,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;6BAClB,QAAQ,EAAE;6BACV,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;4BACnB,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;wBAChD,OAAO,EACL,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;6BAClB,QAAQ,EAAE;6BACV,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;4BACnB,GAAG;4BACH,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;qBACjD,CAAC;gBACJ,CAAC,CAAC,CAAC;QACP,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,yBAAyB;QACvB,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACrC,CAAC;IAED,IAAI,qBAAqB;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAAC;IAC/C,CAAC;IAED,IAAI,qBAAqB,CAAC,OAAe;QACvC,IAAI,CAAC,UAAU,CAAC,qBAAqB,GAAG,OAAO,CAAC;QAChD,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC;IAC1C,CAAC;IAED,IAAI,gBAAgB,CAAC,KAAc;QACjC,IAAI,CAAC,UAAU,CAAC,gBAAgB,GAAG,KAAK,CAAC;QACzC,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,KAAK,CAAC;QACnC,IAAI,CAAC,UAAU,CAAC,gBAAgB,GAAG,KAAK;YACtC,CAAC,CAAC,eAAe,CAAC,iBAAiB;YACnC,CAAC,CAAC,eAAe,CAAC,aAAa,CAAC;QAClC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,2BAA2B,CAAC,UAG3B;QACC,MAAM,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,GAAG,UAAU,CAAC;QAC9D,IAAI,mBAAmB,IAAI,iBAAiB,EAAE;YAC5C,IAAI,CAAC,eAAe,GAAG,mBAAmB,CAAC;YAC3C,IAAI,CAAC,aAAa,GAAG,iBAAiB,CAAC;YACvC,IAAI,CAAC,QAAQ,EAAE,CAAC;SACjB;IACH,CAAC;IAGD,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IA0DS,UAAU;QAClB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC,CAAC;QAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAEO,0BAA0B;QAChC,MAAM,aAAa,GACjB,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC/D,OAAO,CAAC,GAAG,CAAC,yBAAyB,EAAE,aAAa,CAAC,CAAC;QACtD,IAAI,aAAa,EAAE;YACjB,IAAI,CAAC,eAAe,GAAG,aAAa,CAAC,GAAG,CAAC;YACzC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC,GAAG,CAAC;SACxC;IACH,CAAC;IAEO,QAAQ;;QACd,IAAI,CAAC,cAAc,CAAC,cAAc,CAChC,oBAAoB,CAAC,sBAAsB,EAC3C;YACE,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;SAC5C,CACF,CAAC;QAEF,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;QAE7B,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;QAErB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACzB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;SAC/D;QAED,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;SAC7D;QAED,UAAI,IAAI,CAAC,gBAAgB,0CAAE,QAAQ,CAAC,GAAG,GAAG;YACxC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAC1B,4CAA4C,CAC7C,CAAC;SACH;QAED,IACE,IAAI,CAAC,gBAAgB,KAAK,eAAe,CAAC,aAAa;YACvD,IAAI,CAAC,gBAAgB,KAAK,eAAe,CAAC,iBAAiB,EAC3D;YACA,gDAAgD;YAEhD,UAAI,IAAI,CAAC,eAAe,0CAAE,cAAc,CAAC,IAAI,CAAC,gBAAgB,GAAG;gBAC/D,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAC1B,oDAAoD,CACrD,CAAC;aACH;SACF;QAED,IAAI,IAAI,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE;gBAChC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;aAC9D;SACF;QAED,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,GAAG,CAAC,EAAE;YACjE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,oCAAoC,CAAC,CAAC;SACpE;QAED,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAC9C,CAAC;IAED,WAAW;QACT,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEtB,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;YACtB,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC,MAAM,mBAAM,IAAI,CAAC,UAAU,EAAG,CAAC;YACjE,IAAI,CAAC,cAAc,CAAC,cAAc,CAChC,oBAAoB,CAAC,sBAAsB,EAC3C;gBACE,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;aAC5C,CACF,CAAC;YACF,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YACpC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;YACtE,OAAO,IAAI,CAAC,YAAY,CACtB,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CACpC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;gBACb,IAAI,IAAI,CAAC,8BAA8B,EAAE;oBACvC,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;iBAC5C;gBAED,OAAO,MAAM,CAAC;YAChB,CAAC,CAAC,CACH,CACF,CAAC;SACH;aAAM;YACL,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;IACH,CAAC;IAED,oBAAoB,CAClB,KAA+B;QAE/B,MAAM,iBAAiB,GAAyB,KAAK,CAAC;QAEtD,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,iBAAiB,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;SAC5D;QAED,IAAI,IAAI,CAAC,qBAAqB,EAAE;YAC9B,iBAAiB,CAAC,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC;SACtE;QAED,OAAO;YACL,WAAW,EAAE,WAAW,CAAC,IAAI;YAC7B,UAAU,EAAE,iBAAiB;YAC7B,UAAU,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE;YAC1C,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC;SAC1D,CAAC;IACJ,CAAC;IAEM,iBAAiB,CAAC,YAA0B;;QACjD,IAAI,CAAC,gBAAgB,GAAG,YAAY,CAAC,UAAU,CAAC,WAAW,CAAC;QAC5D,IAAI,CAAC,iBAAiB,GAAG,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC;QACvD,IAAI,CAAC,SAAS,GAAG,YAAY,CAAC,UAAU,CAAC,iBAAiB,CAAC;QAC3D,IAAI,CAAC,gBAAgB,GAAG,YAAY,CAAC,UAAU,CAAC,gBAAgB,CAAC;QACjE,IAAI,CAAC,qBAAqB,GAAG,YAAY,CAAC,UAAU,CAAC,qBAAqB,CAAC;QAE3E,6EAA6E;QAC7E,IAAI,CAAC,gBAAgB,GAAG,YAAY,CAAC,UAAU,CAAC,yBAAyB;YACvE,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,yBAAyB,CAAC;YAC3D,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC;QAC5D,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,WAAW,CACtC,YAAY,CAAC,UAAU,CAAC,yBAAyB,EACjD,YAAY,CAAC,UAAU,CAAC,uBAAuB,CAChD,CAAC;QAEF,IAAI,YAAY,CAAC,UAAU,CAAC,WAAW,KAAK,eAAe,CAAC,aAAa,EAAE;YACzE,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC,UAAU,CAAC,uBAAuB;gBACpE,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,uBAAuB,CAAC;gBACzD,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;YAE1D,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CACpC,YAAY,CAAC,UAAU,CAAC,uBAAuB,EAC/C,YAAY,CAAC,UAAU,CAAC,qBAAqB,CAC9C,CAAC;SACH;QAED,IACE,YAAY,CAAC,UAAU,CAAC,WAAW,KAAK,eAAe,CAAC,iBAAiB,EACzE;YACA,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;SACxB;QAED,IAAI,CAAC,cAAc,GAAG,aAAA,YAAY,CAAC,UAAU,0CAAE,kBAAkB,0CAAE,MAAM,EACvE,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,KAAK,CAAC;QACV,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,IAAI,CAAC,SAAS,GAAG,YAAY,CAAC,UAAU,CAAC,kBAAkB,CAAC;SAC7D;QAED,oBAAoB;QACpB,aAAa,CAAC;YACZ,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,UAAU,CAAC,mBAAmB,CAAC;YACpE,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,UAAU,CAAC,iBAAiB,CAAC;SACnE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,gBAAgB,EAAE,cAAc,CAAC,EAAE,EAAE;YAClD,IAAI,gBAAgB,IAAI,cAAc,EAAE;gBACtC,IAAI,CAAC,YAAY,GAAG;oBAClB,IAAI,EAAE,cAAc,CAAC,IAAI;oBACzB,WAAW,EAAE;wBACX,EAAE,EAAE,cAAc,CAAC,EAAE;wBACrB,IAAI,EAAE,cAAc,CAAC,IAAI;wBACzB,OAAO,EAAE,cAAc,CAAC,OAAO;wBAC/B,WAAW,EAAE,cAAc,CAAC,WAAW;wBACvC,aAAa,EAAE,cAAc,CAAC,aAAa;wBAC3C,mBAAmB,EAAE,cAAc,CAAC,mBAAmB;qBACxD;iBACF,CAAC;gBAEF,IAAI,CAAC,cAAc,GAAG;oBACpB,IAAI,EAAE,gBAAgB,CAAC,IAAI;oBAC3B,WAAW,EAAE;wBACX,EAAE,EAAE,gBAAgB,CAAC,EAAE;wBACvB,IAAI,EAAE,gBAAgB,CAAC,IAAI;wBAC3B,OAAO,EAAE,gBAAgB,CAAC,OAAO;wBACjC,WAAW,EAAE,gBAAgB,CAAC,WAAW;wBACzC,aAAa,EAAE,gBAAgB,CAAC,aAAa;wBAC7C,mBAAmB,EAAE,gBAAgB,CAAC,mBAAmB;qBAC1D;iBACF,CAAC;gBAEF,IAAI,YAAY,CAAC,UAAU,CAAC,aAAa,EAAE;oBACzC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC;oBAChB,IAAI,CAAC,kBAAkB,CACrB,YAAY,CAAC,UAAU,CAAC,aAAa,CACtC,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,EAAE;wBAC1B,IAAI,CAAC,WAAW,GAAG;4BACjB,IAAI,EAAE,WAAW,CAAC,IAAI;4BACtB,WAAW,EAAE;gCACX,EAAE,EAAE,WAAW,CAAC,EAAE;gCAClB,IAAI,EAAE,WAAW,CAAC,IAAI;gCACtB,OAAO,EAAE,WAAW,CAAC,OAAO;gCAC5B,WAAW,EAAE,WAAW,CAAC,WAAW;gCACpC,aAAa,EAAE,WAAW,CAAC,aAAa;gCACxC,mBAAmB,EAAE,WAAW,CAAC,mBAAmB;6BACrD;yBACF,CAAC;wBACF,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC;oBACrC,CAAC,CAAC,CAAC;iBACJ;gBAED,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC;aACpC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,oBAAoB,CAC1B,QAA8B;QAE9B,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC3D,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;gBAChC,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAClD,CAAC,YAAY,EAAE,EAAE,CACf,YAAY,CAAC,eAAe,KAAK,oBAAoB,CAAC,aAAa,CACtE,CAAC;gBACF,OAAO,OAAO,CAAC;YACjB,CAAC,CAAC,CAAC;YACH,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,uBAAuB;QAC7B,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,cAAc,EAAE;YAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CACtC,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,cAAc,CACpB,CAAC;YACF,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;YACrD,IAAI,CAAC,QAAQ,EAAE,CAAC;SACjB;IACH,CAAC;IAEO,qBAAqB;QAC3B,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,EAAE;YAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CACtC,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,YAAY,CAClB,CAAC;YACF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;YACpD,IAAI,CAAC,QAAQ,EAAE,CAAC;SACjB;IACH,CAAC;IAED,cAAc;;QACZ,MAAM,KAAK,GAA6B;YACtC,WAAW,EAAE,IAAI;YACjB,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB;YAC7C,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU;YAClC,iBAAiB,EAAE,IAAI,CAAC,aAAa;YACrC,mBAAmB,EAAE,IAAI,CAAC,eAAe;YACzC,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,YAAY;YACtC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,iBAAiB;YACxC,iBAAiB,EAAE,IAAI,CAAC,UAAU,CAAC,SAAS;YAC5C,uBAAuB,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB;YACzD,yBAAyB,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB;YAC3D,qBAAqB,EAAE,IAAI,CAAC,UAAU,CAAC,eAAe;YACtD,uBAAuB,EAAE,IAAI,CAAC,UAAU,CAAC,eAAe;YACxD,aAAa,EAAE,IAAI,CAAC,YAAY;YAChC,kBAAkB,QAAE,IAAI,CAAC,UAAU,CAAC,SAAS,0CAAE,GAAG,CAChD,CAAC,QAAoC,EAAE,EAAE;gBACvC,OAAO,QAAQ,CAAC,IAAI,CAAC;YACvB,CAAC,CACF;SACF,CAAC;QAEF,IAAI,IAAI,CAAC,UAAU,CAAC,YAAY,KAAK,CAAC,EAAE;YACtC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;SACvB;QAED,IAAI,IAAI,CAAC,YAAY,KAAK,EAAE,EAAE;YAC5B,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC;SAC5B;QAED,QAAQ,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE;YACxC,KAAK,kBAAkB,CAAC,MAAM;gBAC5B,KAAK,CAAC,uBAAuB,GAAG,IAAI,CAAC;gBACrC,MAAM;YACR,KAAK,kBAAkB,CAAC,MAAM;gBAC5B,KAAK,CAAC,yBAAyB,GAAG,IAAI,CAAC;gBACvC,MAAM;YACR;gBACE,OAAO,CAAC,IAAI,CACV,yBAAyB,IAAI,CAAC,UAAU,CAAC,gBAAgB,MAAM,CAChE,CAAC;SACL;QAED,QAAQ,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE;YACtC,KAAK,kBAAkB,CAAC,MAAM;gBAC5B,KAAK,CAAC,qBAAqB,GAAG,IAAI,CAAC;gBACnC,MAAM;YACR,KAAK,kBAAkB,CAAC,MAAM;gBAC5B,KAAK,CAAC,uBAAuB,GAAG,IAAI,CAAC;gBACrC,MAAM;YACR;gBACE,OAAO,CAAC,IAAI,CACV,yBAAyB,IAAI,CAAC,UAAU,CAAC,cAAc,MAAM,CAC9D,CAAC;SACL;QAED,QAAQ,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE;YACxC,KAAK,eAAe,CAAC,aAAa,CAAC;YACnC,KAAK,eAAe,CAAC,iBAAiB;gBACpC,KAAK,CAAC,uBAAuB,GAAG,IAAI,CAAC;gBACrC,KAAK,CAAC,qBAAqB,GAAG,IAAI,CAAC;gBACnC,MAAM;SACT;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAA2B,KAAK,CAAC,CAAC;IACnE,CAAC;IAEO,kBAAkB,CAAC,EAAU;QACnC,IAAI,EAAE,EAAE;YACN,OAAO,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SACnE;aAAM;YACL,OAAO,EAAE,EAAE,CAAC;SACb;IACH,CAAC;IAEO,WAAW,CACjB,iBAAyB,EACzB,eAAuB;QAEvB,IAAI,iBAAiB,EAAE;YACrB,OAAO,kBAAkB,CAAC,MAAM,CAAC;SAClC;aAAM,IAAI,eAAe,EAAE;YAC1B,OAAO,kBAAkB,CAAC,MAAM,CAAC;SAClC;QACD;YACE,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED,kBAAkB,CAAC,OAA6B;QAC9C,IAAI,OAAO,GAAqB,EAAE,CAAC;QACnC,IAAI,QAAQ,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QAEtB,IAAI,oBAAoB,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QACtE,IAAI,kBAAkB,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAClE,oBAAoB,GAAG,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,CAAC,CAAC;QACnE,kBAAkB,GAAG,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,CAAC;QAE/D,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC5C,oBAAoB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAqB,EAAE,EAAE;gBACtD,QAAQ,GAAG,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,cAAc,EAAE,CAAC;gBAC9C,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,iBAAiB,CAAC;gBACrD,MAAM,aAAa,GAAwB,EAAE,CAAC;gBAC9C,aAAa,CAAC,UAAU,CAAC,GAAG;oBAC1B,KAAK,EAAE,GAAG,CAAC,KAAK;oBAChB,OAAO,EAAE,KAAK;oBACd,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC,cAAc;oBAC9C,cAAc,EAAE,GAAG,CAAC,cAAc;iBACnC,CAAC;gBACF,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE;oBAChB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;oBAC3B,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC;oBACjE,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,EAAE;wBAChD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;wBACnD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,qBAAqB,mCAClC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,qBAAqB,GACvC,aAAa,CACjB,CAAC;qBACH;yBAAM,IAAI,GAAG,CAAC,KAAK,EAAE;wBACpB,iDAAiD;wBACjD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;4BAC3D,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;4BACnD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,qBAAqB,mCAClC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,qBAAqB,GACvC,aAAa,CACjB,CAAC;yBACH;wBACD,aAAa,CAAC,UAAU,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC;wBACzC,MAAM,WAAW,GAAG;4BAClB,MAAM,EAAE,GAAG;4BACX,QAAQ,EAAE,EAAE;4BACZ,IAAI,EAAE,KAAK;4BACX,SAAS,EAAE,aAAa,CAAC,QAAQ;4BACjC,eAAe,EAAE,CAAC,UAAU,CAAC;4BAC7B,qBAAqB,EAAE,aAAa;4BACpC,KAAK,EAAE,IAAI;4BACX,QAAQ;4BACR,gBAAgB,EAAE,EAAE;4BACpB,gBAAgB,EAAE,EAAE;4BACpB,gBAAgB,EAAE,KAAK;yBACL,CAAC;wBACrB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;qBAC9C;iBACF;qBAAM;oBACL,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;oBAChC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;oBAC3B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG;wBAClB,MAAM,EAAE,GAAG;wBACX,QAAQ,EAAE,EAAE;wBACZ,IAAI,EAAE,KAAK;wBACX,SAAS,EAAE,aAAa,CAAC,QAAQ;wBACjC,eAAe,EAAE,CAAC,UAAU,CAAC;wBAC7B,qBAAqB,EAAE,aAAa;wBACpC,KAAK,EAAE,KAAK;wBACZ,QAAQ;wBACR,gBAAgB,EAAE,EAAE;wBACpB,gBAAgB,EAAE,EAAE;wBACpB,gBAAgB,EAAE,KAAK;qBACL,CAAC;iBACtB;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC1C,kBAAkB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAqB,EAAE,EAAE;gBACpD,QAAQ,GAAG,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,cAAc,EAAE,CAAC;gBAC9C,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,iBAAiB,CAAC;gBACrD,MAAM,aAAa,GAAwB,EAAE,CAAC;gBAC9C,aAAa,CAAC,UAAU,CAAC,GAAG;oBAC1B,KAAK,EAAE,GAAG,CAAC,KAAK;oBAChB,OAAO,EAAE,IAAI;oBACb,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC,cAAc;oBAC9C,cAAc,EAAE,GAAG,CAAC,cAAc;iBACnC,CAAC;gBACF,IACE,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;oBACjB,GAAG,CAAC,KAAK;oBACT,GAAG,CAAC,KAAK,KAAK,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,EAC5C;oBACA,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;oBAC3B,aAAa,CAAC,UAAU,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC;oBACzC,MAAM,WAAW,GAAG;wBAClB,MAAM,EAAE,GAAG;wBACX,QAAQ,EAAE,EAAE;wBACZ,IAAI,EAAE,KAAK;wBACX,SAAS,EAAE,aAAa,CAAC,OAAO;wBAChC,eAAe,EAAE,CAAC,UAAU,CAAC;wBAC7B,qBAAqB,EAAE,aAAa;wBACpC,KAAK,EAAE,IAAI;wBACX,QAAQ;wBACR,gBAAgB,EAAE,EAAE;wBACpB,gBAAgB,EAAE,EAAE;wBACpB,gBAAgB,EAAE,KAAK;qBACjB,CAAC;oBACT,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;iBAC9C;qBAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;oBAC7B,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;oBAC3B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG;wBAClB,MAAM,EAAE,GAAG;wBACX,QAAQ,EAAE,EAAE;wBACZ,IAAI,EAAE,KAAK;wBACX,SAAS,EAAE,aAAa,CAAC,OAAO;wBAChC,eAAe,EAAE,CAAC,UAAU,CAAC;wBAC7B,qBAAqB,EAAE,aAAa;wBACpC,KAAK,EAAE,KAAK;wBACZ,QAAQ;wBACR,gBAAgB,EAAE,EAAE;wBACpB,gBAAgB,EAAE,EAAE;wBACpB,gBAAgB,EAAE,KAAK;qBACjB,CAAC;iBACV;qBAAM,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,KAAK,KAAK,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE;oBACrE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;oBAC3B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;oBACnD,aAAa,CAAC,UAAU,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC;oBAC1C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,qBAAqB,mCAClC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,qBAAqB,GACvC,aAAa,CACjB,CAAC;iBACH;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,cAAc,qBAAQ,OAAO,CAAE,CAAC;QACpC,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,cAAc,CAAC,CAAC;QAEnD,oCAAoC;QACpC,kDAAkD;QAClD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,mBAAmB,CAAC,OAAyB;QAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,MAAM,WAAW,GAAuC,EAAE,CAAC;YAE3D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAClD,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACpC,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC;gBAC/D,IAAI,WAAW,CAAC,cAAc,CAAC,EAAE;oBAC/B,WAAW,CAAC,cAAc,CAAC,CAAC,eAAe,CAAC,IAAI,CAC9C,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,CACzB,CAAC;oBACF,WAAW,CAAC,cAAc,CAAC,CAAC,qBAAqB,mCAC5C,WAAW,CAAC,cAAc,CAAC,CAAC,qBAAqB,GACjD,KAAK,CAAC,qBAAqB,CAC/B,CAAC;iBACH;qBAAM;oBACL,WAAW,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC;iBACrC;aACF;YACD,4BAA4B;YAC5B,4CAA4C;YAC5C,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;SACtE;QACD,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;QACjD,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,gBAAgB,CAAC,OAA4B;QAC3C,IAAI,YAAY,GAAiB,EAAE,CAAC;QACpC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAsB,EAAE,EAAE;YACzC,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,IAAkB,EAAE,EAAE;gBAC3C,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAAqB,EAAE,EAAE;oBACnD,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC;wBACpB,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;wBAClC,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;gBACvC,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,0BAA0B,CACxB,aAA8C,IACvC,CAAC;IAEV,gBAAgB,CAAC,GAAqB;QACpC,CAAC,GAAG,CAAC,WAAW,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YACtD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE;gBAC1D,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG;oBACtD,OAAO,CAAC,cAAc;iBACvB,CAAC;aACH;iBAAM;gBACL,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,IAAI,CACxD,OAAO,CAAC,cAAc,CACvB,CAAC;aACH;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB,CAChB,MAAuB,EACvB,GAA0B,EAC1B,UAAkB,EAClB,QAAgB,EAChB,cAAsB,EACtB,aAA+B;QAE/B,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAEpB,IAAI,CAAC,MAAM,EAAE;YACX,OAAO;SACR;QAED,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC;QACjC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACxC,IAAI,cAAc,GAAG,IAAI,CAAC;QAC1B,IAAI,aAAa,GAAuB,EAAE,CAAC;QAC3C,IAAI,YAAY,GAAuB,EAAE,CAAC;QAC1C,IAAI,YAAY,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACnB,IAAI,KAAK,GAAG,aAAa,CAAC,GAAG,CAAoB,CAAC;YAElD,IACE,KAAK,CAAC,QAAQ,KAAK,QAAQ;gBAC3B,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,UAAU,CAAC,EAC3C;gBACA,IAAI,GAAG,KAAK,SAAS,EAAE;oBACrB,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC;oBAC5B,aAAa,GAAG,EAAE,CAAC;oBACnB,YAAY,GAAG,EAAE,CAAC;oBAClB,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;oBACjC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;oBAClC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;oBAC/B,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;wBAC/B,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC;oBAC9B,CAAC,CAAC,CAAC;iBACJ;qBAAM;oBACL,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC,MAAM,CACpD,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,UAAU,CACtC,CAAC;oBACF,YAAY,GAAG,YAAY,CAAC,MAAM,CAChC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,KAAK,CAAC,MAAM,CACxC,CAAC;iBACH;aACF;iBAAM;gBACL,IACE,KAAK,CAAC,QAAQ,KAAK,QAAQ;oBAC3B,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,cAAc,KAAK,cAAc;oBAC1D,GAAG,KAAK,SAAS,EACjB;oBACA,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;oBAC1D,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;oBACxC,GAAG,KAAK,SAAS;wBACf,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;wBAClC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;oBACpC,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC;iBAC/B;qBAAM;oBACL,2CAA2C;oBAC3C,IAAI,GAAG,KAAK,SAAS,EAAE;wBACrB,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC;qBAC7B;yBAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;wBAC/C,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC;qBAC/B;iBACF;gBAED,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;oBAC/B,IAAI,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;wBAC/C,IAAI,GAAG,KAAK,SAAS,EAAE;4BACrB,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC;4BAC5B,aAAa,GAAG,EAAE,CAAC;4BACnB,YAAY,GAAG,EAAE,CAAC;4BAClB,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;4BACjC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;4BAClC,YAAY,GAAG,IAAI,CAAC;yBACrB;6BAAM;4BACL,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC,MAAM,CACpD,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,UAAU,CACtC,CAAC;4BACF,YAAY,GAAG,YAAY,CAAC,MAAM,CAChC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,KAAK,CAAC,MAAM,CACxC,CAAC;yBACH;qBACF;yBAAM;wBACL,IACE,KAAK,CAAC,QAAQ,KAAK,QAAQ;4BAC3B,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,cAAc,KAAK,cAAc,EAC1D;4BACA,IACE,CAAC,GAAG,KAAK,SAAS;gCAChB,KAAK,CAAC,SAAS,KAAK,aAAa,CAAC,OAAO,CAAC;gCAC5C,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,KAAK,aAAa,CAAC,OAAO,CAAC,EAChE;gCACA,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;gCAC1D,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gCACxC,GAAG,KAAK,SAAS;oCACf,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;oCAClC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gCACpC,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC;6BAC/B;iCAAM,IAAI,YAAY,EAAE;gCACvB,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC;6BAC7B;yBACF;6BAAM;4BACL,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC;yBAC7B;qBACF;gBACH,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;QAEH,oGAAoG;QACpG,0BAA0B;QAC1B,IAAI,GAAG,KAAK,SAAS,EAAE;YACrB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;YAEhE,8DAA8D;YAC9D,aAAa,CAAC,MAAM;gBAClB,CAAC,CAAC,CAAC,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAChE,CAAC,GAAsB,EAAE,EAAE;oBACzB,OAAO,GAAG,CAAC,WAAW,CAAC,iBAAiB,KAAK,UAAU,CAAC;gBAC1D,CAAC,CACF,CAAC;gBACJ,CAAC,CAAC,CAAC,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAC;YAEzC,IACE,IAAI,CAAC,oBAAoB;gBACzB,IAAI,CAAC,qBAAqB,CAAC,cAAc;oBACvC,oBAAoB,CAAC,MAAM;gBAC7B,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,cAAc;oBACnD,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,cAAc,EACtD;gBACA,OAAO,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;gBAClE,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;gBACjC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;aACnC;SACF;aAAM,IAAI,GAAG,KAAK,SAAS,EAAE;YAC5B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;YAE/D,IAAI,CAAC,oBAAoB;gBACvB,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAC7D,CAAC,GAAsB,EAAE,EAAE;oBACzB,OAAO,GAAG,CAAC,WAAW,CAAC,iBAAiB,KAAK,UAAU,CAAC;gBAC1D,CAAC,CACF,CAAC;gBACJ,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAAC;SACzC;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,iBAAyB,EAAE,cAAsB;;QAC1D,oDAAoD;QACpD,IAAI;YACF,IACE,IAAI,CAAC,qBAAqB;gBAC1B,IAAI,CAAC,qBAAqB,CAAC,cAAc;oBACvC,oBAAoB,CAAC,MAAM;gBAC7B,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAC7B;gBACA,gEAAgE;gBAChE,IACE,OAAA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAC/C,MAAM,CAAC,iBAAiB,CAAC,CAC1B,0CAAE,QAAQ,CAAC,cAAc;oBAC1B,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,cAAc;wBACnD,cAAc,EAChB;oBACA,OAAO,IAAI,CAAC;iBACb;gBACD,OAAO,KAAK,CAAC;aACd;SACF;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,CAAC,kCAAkC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;SAClE;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,oBAAoB,CAClB,GAAW,EACX,KAAsB,EACtB,UAAkB;QAElB,IAAI,GAAG,KAAK,SAAS,EAAE;YACrB,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC,MAAM,CACpD,CAAC,OAAe,EAAE,EAAE;gBAClB,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,OAAO,KAAK,UAAU,CAAC;YACxD,CAAC,CACF,CAAC;SACH;aAAM;YACL,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC,MAAM,CACpD,CAAC,OAAe,EAAE,EAAE;gBAClB,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,OAAO,KAAK,UAAU,CAAC;YACvD,CAAC,CACF,CAAC;SACH;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,cAAc,CACZ,IAAY,EACZ,SAAoC;QAEpC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;YACrB,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,IAAI,CAAC,IAAI,EAAE;YACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CACxD,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EACjC,IAAI,CAAC,CAAC,CAAC,CACR,CAAC;SACH;aAAM;YACL,OAAO,EAAE,EAAE,CAAC;SACb;IACH,CAAC;IAED,2BAA2B,CACzB,iBAAoC,EACpC,eAAgC,EAChC,aAAqB;QAErB,OAAO,iBAAiB,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,aAAa,CAAC,IAAI,CAClE,CAAC,YAAY,EAAE,EAAE,CACf,YAAY,CAAC,IAAI,KAAK,eAAe,CAAC,MAAM,CAAC,IAAI;YACjD,CAAC,YAAY,CAAC,KAAK,KAAK,eAAe,CAAC,MAAM,CAAC,KAAK;gBAClD,YAAY,CAAC,WAAW,CAAC,cAAc;oBACrC,eAAe,CAAC,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,CACzD,CAAC;IACJ,CAAC;IAED,4BAA4B,CAAC,iBAAoC;QAC/D,IAAI,IAAI,GAAU,EAAE,CAAC;QACrB,IAAI,iBAAiB,aAAjB,iBAAiB,uBAAjB,iBAAiB,CAAE,QAAQ,CAAC,MAAM,EAAE;YACtC,IAAI,GAAG,iBAAiB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;gBAChD,OAAO;oBACL,QAAQ,EAAE,OAAO,CAAC,QAAQ;oBAC1B,iBAAiB,EAAE,OAAO,CAAC,cAAc;oBACzC,oBAAoB,EAAE,OAAO,CAAC,MAAM;oBACpC,eAAe,EAAE,OAAO,CAAC,cAAc;oBACvC,kBAAkB,EAAE,OAAO,CAAC,MAAM;iBACnC,CAAC;YACJ,CAAC,CAAC,CAAC;SACJ;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEK,wBAAwB,CAC5B,SAAiB,EACjB,SAAmC,EACnC,iBAAoC,EACpC,eAAgC;;YAGhC,IAAI,eAA+B,CAAC;YACpC,8EAA8E;YAC9E,IAAI,iBAAiB,CAAC,YAAY,EAAE;gBAClC,eAAe,GAAG,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;aACpF;YAED,IAAI,iBAAiB,CAAC,UAAU,EAAE;gBAChC,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;aAC/B;YACD,MAAM,SAAS,GACb,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;YAC9C,MAAM,MAAM,GAAG,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,OAAO,CAAC,KAAK,CAAC;YACxC,IAAI,MAAM,EAAE;gBACV,MAAM,wBAAwB,GAAG,IAAI,CAAC,2BAA2B,CAC/D,iBAAiB,EACjB,eAAe,EACf,CAAC,CACF,CAAC;gBACF,MAAM,IAAI,GAAG,IAAI,CAAC,4BAA4B,CAAC,iBAAiB,CAAC,CAAC;gBAClE,MAAM,eAAe,GAAG,wBAAwB,CAAC,eAAe,CAAC,GAAG,CAClE,CAAC,gBAAgB,EAAE,EAAE;oBACnB,OAAO;wBACL,EAAE,EAAE,gBAAgB,CAAC,EAAE;wBACvB,IAAI,EAAE,gBAAgB,CAAC,IAAI;wBAC3B,IAAI,EAAE,gBAAgB,CAAC,IAAI;qBAC5B,CAAC;gBACJ,CAAC,CACF,CAAC;gBAEF,MAAM,UAAU,GAAmB;oBACjC,MAAM,EAAE,MAAM,CAAC,EAAE;oBACjB,OAAO,EAAE,SAAS;oBAClB,MAAM,EAAE;wBACN,YAAY,EAAE,wBAAwB,CAAC,YAAY,CAAC,GAAG,CACrD,CAAC,OAAoB,EAAE,EAAE;4BACvB,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC;wBAC9D,CAAC,CACF;wBACD,aAAa,EAAE;4BACb,eAAe,EAAE,iBAAiB,CAAC,cAAc;4BACjD,kBAAkB,EAAE,iBAAiB,CAAC,EAAE;4BACxC,iBAAiB,EAAE,iBAAiB,CAAC,cAAc;4BACnD,oBAAoB,EAAE,iBAAiB,CAAC,IAAI;4BAC5C,eAAe,EAAE;gCACf;oCACE,YAAY,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI;oCACjD,iBAAiB,EAAE,wBAAwB,CAAC,IAAI;oCAChD,KAAK,EAAE,wBAAwB,CAAC,KAAK;oCACrC,IAAI;iCACL;6BACF;yBACF;wBACD,qBAAqB,EACnB,iBAAiB,CAAC,WAAW,CAAC,qBAAqB;wBACrD,QAAQ,EAAE;4BACR,eAAe,EAAE;gCACf,wBAAwB,CAAC,WAAW,CAAC,cAAc;6BACpD;4BACD,iBAAiB,EAAE,wBAAwB,CAAC,WAAW,CAAC,iBAAiB;yBAC1E;wBACD,eAAe;qBAChB;oBACD,MAAM,EAAE,SAAS,CAAC,MAAM;oBACxB,KAAK,EAAE,wBAAwB,CAAC,KAAK;oBACrC,QAAQ,EAAE,wBAAwB,CAAC,QAAwB;oBAC3D,WAAW,EAAE,SAAS;oBACtB,UAAU,EAAE,iBAAiB,CAAC,UAAU;oBACxC,eAAe,EAAE,iBAAiB,CAAC,eAAe;oBAClD,YAAY,EAAE,iBAAiB,CAAC,cAAc;iBAC/C,CAAA;gBAED,yDAAyD;gBACzD,IAAI,eAAe,EAAE;oBACnB,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,GAAG,eAAe,CAAC;iBAC3D;gBAED,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CACnC,UAAU,EACV,SAAS,EACT,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,UAAU,CAChB,CAAC;aACH;YACD,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;KAAA;IAEK,wBAAwB,CAC5B,SAAiB,EACjB,SAAmC,EACnC,QAA2B,EAC3B,OAA0B,EAC1B,eAAgC;;YAEhC,IAAI,QAAQ,CAAC,UAAU,EAAE;gBACvB,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;aAC/B;YAED,IAAI,cAA8B,CAAC;YACnC,IAAI,eAA+B,CAAC;YAEpC,8EAA8E;YAC9E,IAAI,OAAO,CAAC,YAAY,EAAE;gBACxB,cAAc,GAAG,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;aACzE;YAED,IAAI,QAAQ,CAAC,YAAY,EAAE;gBACzB,eAAe,GAAG,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;aAC3E;YAED,MAAM,SAAS,GACb,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;YAC9C,MAAM,MAAM,GAAG,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,OAAO,CAAC,KAAK,CAAC;YACxC,IAAI,MAAM,EAAE;gBACV,MAAM,wBAAwB,GAAG,IAAI,CAAC,2BAA2B,CAC/D,QAAQ,EACR,eAAe,EACf,CAAC,CACF,CAAC;gBACF,MAAM,+BAA+B,GAAG,IAAI,CAAC,2BAA2B,CACtE,OAAO,EACP,eAAe,EACf,CAAC,CACF,CAAC;gBACF,MAAM,YAAY,GAAG,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC;gBACjE,MAAM,WAAW,GAAG,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC,CAAC;gBAC/D,MAAM,eAAe,GAAG,wBAAwB,CAAC,eAAe,CAAC,GAAG,CAClE,CAAC,gBAAiC,EAAE,EAAE;oBACpC,OAAO;wBACL,EAAE,EAAE,gBAAgB,CAAC,EAAE;wBACvB,IAAI,EAAE,gBAAgB,CAAC,IAAI;wBAC3B,IAAI,EAAE,gBAAgB,CAAC,IAAI;qBAC5B,CAAC;gBACJ,CAAC,CACF,CAAC;gBAEF,MAAM,UAAU,GAAmB;oBACjC,MAAM,EAAE,MAAM,CAAC,EAAE;oBACjB,OAAO,EAAE,SAAS;oBAClB,MAAM,EAAE;wBACN,YAAY,EAAE,wBAAwB,CAAC,YAAY,CAAC,GAAG,CACrD,CAAC,OAAoB,EAAE,EAAE;4BACvB,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC;wBAC9D,CAAC,CACF;wBACD,aAAa,EAAE;4BACb,eAAe,EAAE,QAAQ,CAAC,cAAc;4BACxC,kBAAkB,EAAE,QAAQ,CAAC,EAAE;4BAC/B,iBAAiB,EAAE,QAAQ,CAAC,cAAc;4BAC1C,oBAAoB,EAAE,QAAQ,CAAC,IAAI;4BACnC,eAAe,EAAE;gCACf;oCACE,YAAY,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI;oCACxC,iBAAiB,EAAE,wBAAwB,CAAC,IAAI;oCAChD,KAAK,EAAE,wBAAwB,CAAC,KAAK;oCACrC,IAAI,EAAE,YAAY;iCACnB;6BACF;yBACF;wBACD,YAAY,EAAE;4BACZ,eAAe,EAAE,OAAO,CAAC,cAAc;4BACvC,kBAAkB,EAAE,OAAO,CAAC,EAAE;4BAC9B,iBAAiB,EAAE,OAAO,CAAC,cAAc;4BACzC,oBAAoB,EAAE,OAAO,CAAC,IAAI;4BAClC,eAAe,EAAE;gCACf;oCACE,YAAY,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI;oCACvC,iBAAiB,EAAE,wBAAwB,CAAC,IAAI;oCAChD,IAAI,EAAE,WAAW;iCAClB;6BACF;yBACF;wBACD,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAAC,qBAAqB;wBACjE,QAAQ,EAAE;4BACR,eAAe,EAAE;gCACf,wBAAwB,CAAC,WAAW,CAAC,cAAc;6BACpD;4BACD,iBAAiB,EAAE,wBAAwB,CAAC,WAAW,CAAC,iBAAiB;yBAC1E;wBACD,eAAe;wBACf,MAAM,EAAE;4BACN,eAAe,EAAE;gCACf,+BAA+B,CAAC,WAAW,CAAC,cAAc;6BAC3D;4BACD,iBAAiB,EAAE,+BAA+B,CAAC,WAAW,CAAC,iBAAiB;yBACjF;qBACF;oBACD,MAAM,EAAE,SAAS,CAAC,MAAM;oBACxB,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK;oBACnC,QAAQ,EAAE,wBAAwB,CAAC,QAAwB;oBAC3D,WAAW,EAAE,SAAS;oBACtB,UAAU,EAAE,QAAQ,CAAC,UAAU;oBAC/B,eAAe,EAAE,QAAQ,CAAC,eAAe;oBACzC,YAAY,EAAE,QAAQ,CAAC,cAAc;oBACrC,WAAW,EAAE,OAAO,CAAC,cAAc;iBACpC,CAAA;gBAED,2EAA2E;gBAC3E,IAAI,cAAc,EAAE;oBAClB,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,GAAG,cAAc,CAAC;iBACxD;gBACD,IAAI,eAAe,EAAE;oBACnB,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,GAAG,eAAe,CAAC;iBAC3D;gBAED,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CACnC,UAAU,EACV,SAAS,EACT,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,UAAU,CAChB,CAAC;aACH;YACD,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;KAAA;IAED,wBAAwB,CAAC,eAAgC;QACvD,OAAO,CAAC;gBACN,IAAI,EAAE,eAAe,CAAC,WAAW;gBACjC,QAAQ,EAAE,eAAe,CAAC,QAAQ;gBAClC,IAAI,EAAE,eAAe,CAAC,IAAI;aAC3B,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,OAAqB;QACpC,MAAM,gBAAgB,qBAAQ,OAAO,CAAE,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YACxC,gBAAgB,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAmB,EAAE,CAAmB,EAAE,EAAE;gBACtE,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;gBACvB,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;gBACvB,OAAO,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACxD,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IACD,wBAAwB,CAAC,OAAyB;QAChD,MAAM,gBAAgB,qBAAQ,OAAO,CAAE,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YACxC,gBAAgB,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,IAAI,CACjC,CAAC,CAAkB,EAAE,CAAkB,EAAE,EAAE;gBACzC,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;gBAC9B,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;gBAC9B,OAAO,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACxD,CAAC,CACF,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IACD,iBAAiB,CAAC,OAA6B;QAC7C,IAAI,CAAC,OAAO,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QACjC,IAAI,QAAQ,CAAC;QACb,IAAI;YACF,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;SAC1E;QAAC,OAAO,KAAK,EAAE;YACd,QAAQ,GAAG,KAAK,CAAC;SAClB;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAC/C,OAAO;YACL,MAAM,EAAE,KAAK;YACb,YAAY,EAAE,QAAQ;SACvB,CAAC;IACJ,CAAC;IACD,kBAAkB,CAAC,OAA6B;QAC9C,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,OAAO,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QACjC,IAAI,WAAW,GAAa,EAAE,CAAC;QAE/B,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YACrB,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;gBAC1B,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;oBACxB,IAAI,cAAc,GAAW,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;oBACxD,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE;;wBAClC,IAAI,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC;wBAC/B,IAAI,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC;wBAC/B,IACE,QAAQ,KAAK,OAAO;4BACpB,CAAC,OAAA,IAAI,CAAC,cAAc,0CAAE,KAAK,IAAG,QAAQ,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAC/D;4BACA,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;yBACjC;6BAAM,IACL,QAAQ,KAAK,UAAU;4BACvB,CAAC,OAAA,IAAI,CAAC,iBAAiB,0CAAE,KAAK,IAAG,QAAQ;gCACvC,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAC1B;4BACA,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC;yBACpC;wBACD,IAAI,QAAQ,KAAK,cAAc,EAAE;4BAC/B,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;yBAClC;oBACH,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC;IAClC,CAAC;IAED,6BAA6B,CAC3B,WAA4C;QAE5C,OAAO,IAAI,CAAC,OAAO;aAChB,iBAAiB,CAAC,WAAW,CAAC,cAAc,EAAE,WAAW,CAAC,cAAc,CAAC;aACzE,QAAQ,EAAE,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,MAAwB;QACxC,IAAI,YAAY,GAAG,IAAI,CAAC;QAExB,YAAY,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE;YAC3D,OAAO,aAAa,CAAC,IAAI,KAAK,SAAS,CAAC;QAC1C,CAAC,CAAC,CAAC;QAEH,OAAO,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,kBAAkB;QAChB,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;QACjC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACnC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;IACjC,CAAC;;AAloDe,2CAAsB,GAAG,aAAa,CAAC;AACvC,4CAAuB,GAAG,cAAc,CAAC;AACzC,kCAAa,GAAG,SAAS,CAAC","sourcesContent":["import moment from 'moment';\r\nimport { of, Observable, BehaviorSubject, combineLatest } from 'rxjs';\r\nimport { map, take, tap } from 'rxjs/operators';\r\nimport { BaseEnterpriseSearch } from './base-enterprise';\r\nimport { BaseStorageService } from '../services/storage.service';\r\nimport { BaseHelperRoutines } from './helpers';\r\nimport { RailTicketGroups } from '../interfaces/rail-ticket-groups.interface';\r\nimport {\r\n  RailResultIndifiers,\r\n  RailTicketGroup,\r\n  TicketGroups\r\n} from '../interfaces/rail-ticket-group.interface';\r\nimport { RailDirection } from './rail-direction.enum';\r\nimport { ValueDisplay } from '../interfaces/value-display';\r\nimport {\r\n  NgbDateStruct,\r\n  RailQuoteResultArray,\r\n  RecentSearch,\r\n  RecursivePartial\r\n} from '../types/types';\r\nimport {\r\n  BasketItem,\r\n  CurrencyCode,\r\n  RailAccount,\r\n  RailClass,\r\n  RailJourneyOption,\r\n  RailJourneyOptions,\r\n  RailJourneyType,\r\n  RailProvider,\r\n  RailSegment,\r\n  RailStation,\r\n  RailTicketOption,\r\n  RailTicketQueue,\r\n  ReferenceRailCardQualifier,\r\n  SaveRecentSearchMutationVariables,\r\n  SearchRailQueryVariables,\r\n  ServiceType,\r\n  RailTicketExtra\r\n} from '../types/graphql.types';\r\nimport {\r\n  BaseRailQuoteFetcher,\r\n  RailQuoteFetcherType\r\n} from '../fetchers/rail-quote-fetcher';\r\nimport {\r\n  BaseGetRailStationFetcher,\r\n  GetRailStationFetcherType\r\n} from '../fetchers/get-rail-station.fetcher';\r\nimport {\r\n  EnterpriseBasketServiceInterface,\r\n  InternalBasketInterface\r\n} from '../interfaces/Ienterprise-basket.service';\r\nimport { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';\r\nimport {\r\n  RailEnterpriseSearchInterface,\r\n  RailTempParams\r\n} from '../interfaces/Irail-enterprise-search';\r\nimport { Traveller } from '../models/traveller.object';\r\nimport { ICheapestPrice } from '../interfaces/cheapest-price';\r\nimport { IRailAirportExpressStations } from '../interfaces/rail-airport-express-stations.interface';\r\nimport { RailBasketItem, TicketExtras } from '../interfaces/rail-basket-item.interface';\r\nimport { RailRecentSearchArgs } from '../interfaces/rail-recent-search-args.interface';\r\n\r\nexport enum RailSearchCriteria {\r\n  Depart = 'Depart After',\r\n  Arrive = 'Arrive Before'\r\n}\r\n\r\nexport enum RailTicketOptionType { // may need to be expanded for dual/split\r\n  Return = 'Return',\r\n  Single = 'Single'\r\n}\r\n\r\nexport class RailEnterpriseSearch<\r\n    Q extends RailQuoteFetcherType,\r\n    GRS_Q extends GetRailStationFetcherType\r\n  >\r\n  extends BaseEnterpriseSearch<\r\n    RailTempParams,\r\n    RailQuoteResultArray,\r\n    RailQuoteResultArray\r\n  >\r\n  implements RailEnterpriseSearchInterface\r\n{\r\n  static readonly STORAGE_SESSION_PARAMS = 'search_rail';\r\n  static readonly STORAGE_SESSION_RESULTS = 'rail_results';\r\n  static readonly PASSING_POINT = 'Passing';\r\n  private travellers: Traveller[];\r\n\r\n  protected resultsSessionName = RailEnterpriseSearch.STORAGE_SESSION_RESULTS;\r\n\r\n  public searchTypes = [\r\n    { display: 'Return', value: RailJourneyType.ReturnJourney },\r\n    { display: 'One-Way', value: RailJourneyType.SingleJourney }\r\n    // { display: 'Open Return', value: RailJourneyType.OpenReturnJourney },\r\n    // { display: 'Dual Singles', value: RailJourneyType.DualSingleJourney },\r\n  ];\r\n\r\n  public classTypes = [\r\n    { display: 'Any', value: RailClass.All },\r\n    { display: 'Standard', value: RailClass.Standard },\r\n    { display: 'First', value: RailClass.First }\r\n  ];\r\n\r\n  public airportExpressStations: IRailAirportExpressStations[] = [\r\n    { code: 'HP1-3', name: 'Heathrow T1-3 - Paddington' },\r\n    { code: 'HP4', name: 'Heathrow T4 - Paddington' },\r\n    { code: 'HP5', name: 'Heathrow T5 - Paddington' },\r\n    { code: 'PH1-3', name: 'Paddington - Heathrow T1-3' },\r\n    { code: 'PH4', name: 'Paddington - Heathrow T4' },\r\n    { code: 'PH5', name: 'Paddington - Heathrow T5' },\r\n    { code: 'GV', name: 'Gatwick - Victoria' },\r\n    { code: 'VG', name: 'Victoria - Gatwick' },\r\n    { code: 'SL', name: 'Stansted - Liverpool Street' },\r\n    { code: 'LS', name: 'Liverpool Street - Stansted' }\r\n  ];\r\n\r\n  public airportExpressStationsCodes: {\r\n    [key: string]: { dep: string; arr: string };\r\n  } = {\r\n    'HP1-3': { dep: 'HXX', arr: 'PAD' },\r\n    'PH1-3': { dep: 'PAD', arr: 'HXX' },\r\n    HP4: { dep: 'HAF', arr: 'PAD' },\r\n    PH4: { dep: 'PAD', arr: 'HAF' },\r\n    HP5: { dep: 'HWV', arr: 'PAD' },\r\n    PH5: { dep: 'PAD', arr: 'HWV' },\r\n    GV: { dep: 'GTW', arr: 'VIC' },\r\n    VG: { dep: 'VIC', arr: 'GTW' },\r\n    SL: { dep: 'SSD', arr: 'LST' },\r\n    LS: { dep: 'LST', arr: 'SSD' }\r\n  };\r\n\r\n  public railCriteria = [RailSearchCriteria.Depart, RailSearchCriteria.Arrive];\r\n\r\n  public travelCards = [\r\n    { display: 'Young persons railcard', value: 'YNG' },\r\n    { display: 'Disability railcard', value: 'DIS' },\r\n    { display: 'Family railcard', value: 'FAM' },\r\n    { display: 'Forces railcard', value: 'HMF' },\r\n    { display: 'Travel agency discount', value: 'TAD' }\r\n  ];\r\n\r\n  // YNG: \"Young persons railcard\",\r\n  // DIS: \"Disability railcard\",\r\n  // FAM: \"Family railcard\",\r\n  // HMF: \"Forces railcard\",\r\n  // TAD: \"Travel agency discount\"\r\n  public removePassingPointsFromResults = true;\r\n  public type: ServiceType = ServiceType.Rail;\r\n  public minOutboundDate: NgbDateStruct = {\r\n    year: moment().year(),\r\n    month: moment().month() + 1,\r\n    day: moment().date()\r\n  };\r\n  public minInboundDate: NgbDateStruct = {\r\n    year: moment().year(),\r\n    month: moment().month() + 1,\r\n    day: moment().date()\r\n  };\r\n  public maxDate: NgbDateStruct = {\r\n    // ENT-1557 - max Evolvi search date is 6 months in future\r\n    year: moment().add('month', 6).year(),\r\n    month: moment().add('month', 6).month(),\r\n    day: moment().add('month', 6).date()\r\n  };\r\n  private _timeArray: ValueDisplay[];\r\n  private _canCombine: any;\r\n  private _chosenOutboundTicket: RecursivePartial<RailTicketOption>;\r\n  private _chosenInboundTicket: RecursivePartial<RailTicketOption>;\r\n  private _chosenOutboundJourney: RecursivePartial<RailJourneyOption>;\r\n  private _chosenInboundJourney: RecursivePartial<RailJourneyOption>;\r\n  private _chosenTicketGroup: RailTicketGroup;\r\n  private _viaLocation: string;\r\n  private _travellingFrom: string;\r\n  private _travellingTo: string;\r\n  protected _originalUserSearch: RailTempParams;\r\n\r\n  get chosenTicketGroup(): RailTicketGroup {\r\n    return this._chosenTicketGroup;\r\n  }\r\n\r\n  get chosenTotalPrice(): number {\r\n    if (this._chosenOutboundTicket) {\r\n      if (this._chosenInboundTicket) {\r\n        // now check if they are returns or dual\r\n        if (\r\n          this._chosenOutboundTicket.singleOrReturn ===\r\n            RailTicketOptionType.Return &&\r\n          this._chosenInboundTicket.singleOrReturn ===\r\n            RailTicketOptionType.Return\r\n        ) {\r\n          // they should both have the same price\r\n          return this._chosenOutboundTicket.price;\r\n        }\r\n        return (\r\n          this._chosenOutboundTicket.price + this._chosenInboundTicket.price\r\n        );\r\n      }\r\n\r\n      return this._chosenOutboundTicket.price;\r\n    }\r\n\r\n    return 0;\r\n  }\r\n\r\n  get chosenTickets(): any {\r\n    return {\r\n      Outbound: this._chosenOutboundTicket,\r\n      Inbound: this._chosenInboundTicket\r\n    };\r\n  }\r\n\r\n  get chosenOutboundJourney(): RecursivePartial<RailJourneyOption> {\r\n    return this._chosenOutboundJourney;\r\n  }\r\n\r\n  get chosenInboundJourney(): RecursivePartial<RailJourneyOption> {\r\n    return this._chosenInboundJourney;\r\n  }\r\n\r\n  get openReturn(): boolean {\r\n    return this.tempParams.openReturn;\r\n  }\r\n\r\n  set openReturn(newVal: boolean) {\r\n    this.tempParams.openReturn = newVal;\r\n\r\n    if (newVal) {\r\n      this.tempParams.chosenSearchType = RailJourneyType.OpenReturnJourney;\r\n    }\r\n    this._isValid();\r\n  }\r\n\r\n  get chosenSearchType(): RailJourneyType {\r\n    return this.tempParams.chosenSearchType;\r\n  }\r\n\r\n  set chosenSearchType(newType: RailJourneyType) {\r\n    this.tempParams.chosenSearchType = newType;\r\n    if (newType === RailJourneyType.SingleJourney) {\r\n      this.openReturn = false;\r\n    }\r\n    this._isValid();\r\n  }\r\n\r\n  get noOfAdults(): number {\r\n    return this.tempParams.noOfAdults;\r\n  }\r\n\r\n  set noOfAdults(adults: number) {\r\n    this.tempParams.noOfAdults = adults;\r\n    this._isValid();\r\n  }\r\n\r\n  get noOfChildren(): number {\r\n    return this.tempParams.noOfChildren;\r\n  }\r\n\r\n  set noOfChildren(children: number) {\r\n    this.tempParams.noOfChildren = children;\r\n    this._isValid();\r\n  }\r\n\r\n  get travellingTo(): any {\r\n    return this.tempParams.travellingTo;\r\n  }\r\n\r\n  set travellingTo(tt: any) {\r\n    this.tempParams.travellingTo = tt;\r\n\r\n    this._travellingTo = '';\r\n    if (tt?.railstation?.id) {\r\n      this._travellingTo = tt.railstation.id;\r\n    }\r\n\r\n    this._isValid();\r\n  }\r\n\r\n  get travellingFrom(): any {\r\n    return this.tempParams.travellingFrom;\r\n  }\r\n\r\n  set travellingFrom(tt: any) {\r\n    this.tempParams.travellingFrom = tt;\r\n    this._travellingFrom = '';\r\n    if (tt?.railstation?.id) {\r\n      this._travellingFrom = tt.railstation.id;\r\n    }\r\n\r\n    this._isValid();\r\n  }\r\n\r\n  get chosenRailClass(): RailClass {\r\n    return this.tempParams.chosenSearchClass;\r\n  }\r\n\r\n  set chosenRailClass(newClass: RailClass) {\r\n    this.tempParams.chosenSearchClass = newClass;\r\n  }\r\n\r\n  get chosenSearchClass(): RailClass {\r\n    return this.tempParams.chosenSearchClass;\r\n  }\r\n\r\n  set chosenSearchClass(classR: RailClass) {\r\n    this.tempParams.chosenSearchClass = classR;\r\n    this._isValid();\r\n  }\r\n\r\n  get extraTime(): boolean {\r\n    return this.tempParams.extraTime;\r\n  }\r\n\r\n  set extraTime(extra: boolean) {\r\n    this.tempParams.extraTime = extra;\r\n    this._isValid();\r\n  }\r\n\r\n  get via(): boolean {\r\n    return this.tempParams.via;\r\n  }\r\n\r\n  set via(via: boolean) {\r\n    this.tempParams.via = via;\r\n    this._isValid();\r\n  }\r\n\r\n  get viaLocation(): any {\r\n    return this.tempParams.viaLocation;\r\n  }\r\n\r\n  set viaLocation(viaLocation: any) {\r\n    this.tempParams.viaLocation = viaLocation;\r\n\r\n    this._viaLocation = '';\r\n    if (viaLocation?.railstation?.id) {\r\n      this._viaLocation = viaLocation.railstation.id;\r\n    }\r\n\r\n    this._isValid();\r\n  }\r\n\r\n  get outBoundDateTime(): moment.Moment {\r\n    return this.tempParams.outBoundDateTime;\r\n  }\r\n\r\n  set outBoundDateTime(newDateTime: moment.Moment) {\r\n    this.tempParams.outBoundDateTime = newDateTime;\r\n    if (newDateTime && newDateTime.isValid()) {\r\n      this._outbound_date = this.helpers.momentToNgDate(newDateTime);\r\n      this._outbound_time = moment(newDateTime).format('HHmm')\r\n        ? moment(newDateTime).format('HHmm')\r\n        : '0700';\r\n    }\r\n\r\n    this.minInboundDate = {\r\n      year: newDateTime.year(),\r\n      month: newDateTime.month() + 1,\r\n      day: newDateTime.date()\r\n    };\r\n\r\n    if (\r\n      this.outBoundDateTime &&\r\n      this.inBoundDateTime &&\r\n      this.outBoundDateTime.isAfter(this.inBoundDateTime)\r\n    ) {\r\n      this.inBoundDateTime = this.inBoundDateTime\r\n        .set('date', newDateTime.date())\r\n        .set('month', newDateTime.month())\r\n        .set('year', newDateTime.year());\r\n    }\r\n\r\n    this._isValid();\r\n  }\r\n\r\n  get outboundCriteria(): RailSearchCriteria {\r\n    return this.tempParams.outboundCriteria;\r\n  }\r\n\r\n  set outboundCriteria(newCrit: RailSearchCriteria) {\r\n    // console.warn(`+++ Setting New Criteria: ${newCrit} +++`);\r\n    this.tempParams.outboundCriteria = newCrit;\r\n\r\n    this._isValid();\r\n  }\r\n\r\n  get inBoundDateTime(): moment.Moment {\r\n    return this.tempParams.inBoundDateTime;\r\n  }\r\n\r\n  set inBoundDateTime(newDateTime: moment.Moment) {\r\n    this.tempParams.inBoundDateTime = newDateTime;\r\n    if (newDateTime && newDateTime.isValid()) {\r\n      this._return_date = this.helpers.momentToNgDate(newDateTime);\r\n      this._return_time = moment(newDateTime).format('HHmm')\r\n        ? moment(newDateTime).format('HHmm')\r\n        : '1600';\r\n    }\r\n    this._isValid();\r\n  }\r\n\r\n  // !date and time is handled differently for LU\r\n  private _outbound_date: NgbDateStruct = null;\r\n\r\n  get outbound_date(): NgbDateStruct {\r\n    return this._outbound_date;\r\n  }\r\n\r\n  set outbound_date(value: NgbDateStruct) {\r\n    this._outbound_date = value;\r\n    this._updateOutboundDateTime();\r\n  }\r\n\r\n  private _outbound_time: string = null;\r\n  get outbound_time(): string {\r\n    return this._outbound_time;\r\n  }\r\n\r\n  set outbound_time(value: string) {\r\n    this._outbound_time = value;\r\n    this._updateOutboundDateTime();\r\n  }\r\n\r\n  private _return_date: NgbDateStruct = null;\r\n\r\n  get return_date(): NgbDateStruct {\r\n    return this._return_date;\r\n  }\r\n\r\n  set return_date(value: NgbDateStruct) {\r\n    this._return_date = value;\r\n    this._updateReturnDateTime();\r\n  }\r\n\r\n  private _return_time: string = null;\r\n  get return_time(): string {\r\n    return this._return_time;\r\n  }\r\n\r\n  set return_time(value: string) {\r\n    this._return_time = value;\r\n    this._updateReturnDateTime();\r\n  }\r\n\r\n  get returnCriteria(): RailSearchCriteria {\r\n    return this.tempParams.returnCriteria;\r\n  }\r\n\r\n  set returnCriteria(newCrit: RailSearchCriteria) {\r\n    this.tempParams.returnCriteria = newCrit;\r\n    this._isValid();\r\n  }\r\n\r\n  get carnetTicket(): boolean {\r\n    return this.tempParams.carnetTicket;\r\n  }\r\n\r\n  set carnetTicket(newCarnet: boolean) {\r\n    this.tempParams.carnetTicket = newCarnet;\r\n    this._isValid();\r\n  }\r\n\r\n  get disableAutoDiscounts(): boolean {\r\n    return this.tempParams.disableAutoDiscounts;\r\n  }\r\n\r\n  set disableAutoDiscounts(newDis: boolean) {\r\n    this.tempParams.disableAutoDiscounts = newDis;\r\n    this._isValid();\r\n  }\r\n\r\n  get prioritiseByPrice(): boolean {\r\n    return this.tempParams.prioritiseByPrice;\r\n  }\r\n\r\n  set prioritiseByPrice(newPriority: boolean) {\r\n    this.tempParams.prioritiseByPrice = newPriority;\r\n    this._isValid();\r\n  }\r\n\r\n  get applyRailcards(): boolean {\r\n    return this.tempParams.applyRailcards;\r\n  }\r\n\r\n  set applyRailcards(apCards: boolean) {\r\n    this.tempParams.applyRailcards = apCards;\r\n  }\r\n\r\n  get railCards(): ReferenceRailCardQualifier[] {\r\n    return this.tempParams.railCards;\r\n  }\r\n\r\n  set railCards(value: ReferenceRailCardQualifier[]) {\r\n    this.tempParams.railCards = value;\r\n  }\r\n\r\n  public get timeArray(): ValueDisplay[] {\r\n    this._timeArray =\r\n      this._timeArray ||\r\n      Array(48)\r\n        .fill(0)\r\n        .map((_, index: number) => {\r\n          return {\r\n            value:\r\n              Math.floor(index / 2)\r\n                .toString()\r\n                .padStart(2, '0') +\r\n              ((index % 2) * 30).toString().padStart(2, '0'),\r\n            display:\r\n              Math.floor(index / 2)\r\n                .toString()\r\n                .padStart(2, '0') +\r\n              ':' +\r\n              ((index % 2) * 30).toString().padStart(2, '0')\r\n          };\r\n        });\r\n    return this._timeArray;\r\n  }\r\n\r\n  getAirportExpressStations(): { code: string; name: string }[] {\r\n    return this.airportExpressStations;\r\n  }\r\n\r\n  get airportExpressStation(): string {\r\n    return this.tempParams.airportExpressStation;\r\n  }\r\n\r\n  set airportExpressStation(station: string) {\r\n    this.tempParams.airportExpressStation = station;\r\n    this._setAirportExpressStations();\r\n    this._isValid();\r\n  }\r\n\r\n  get isAirportExpress(): boolean {\r\n    return this.tempParams.isAirportExpress;\r\n  }\r\n\r\n  set isAirportExpress(value: boolean) {\r\n    this.tempParams.isAirportExpress = value;\r\n    this.tempParams.openReturn = value;\r\n    this.tempParams.chosenSearchType = value\r\n      ? RailJourneyType.OpenReturnJourney\r\n      : RailJourneyType.ReturnJourney;\r\n    this._isValid();\r\n  }\r\n\r\n  setAirportExpressStationIds(stationIds: {\r\n    departureLocationId: string;\r\n    arrivalLocationId: string;\r\n  }): void {\r\n    const { departureLocationId, arrivalLocationId } = stationIds;\r\n    if (departureLocationId && arrivalLocationId) {\r\n      this._travellingFrom = departureLocationId;\r\n      this._travellingTo = arrivalLocationId;\r\n      this._isValid();\r\n    }\r\n  }\r\n\r\n  private _cheapestStandard: RailTicketOption = null;\r\n  get cheapestStandard(): RailTicketOption {\r\n    return this._cheapestStandard;\r\n  }\r\n  private _cheapestFirst: RailTicketOption = null;\r\n  get cheapestFirst(): RailTicketOption {\r\n    return this._cheapestFirst;\r\n  }\r\n\r\n  constructor(\r\n    private Railfetcher: BaseRailQuoteFetcher<Q>,\r\n    private getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>,\r\n    private helpers: BaseHelperRoutines,\r\n    private basketService: EnterpriseBasketServiceInterface,\r\n    storageService: BaseStorageService,\r\n    private searchService: EnterpriseSearchServiceInterface\r\n  ) {\r\n    super(storageService);\r\n\r\n    const data: {\r\n      query: {};\r\n      tempParams: RailTempParams;\r\n      originalUserSearch: RailTempParams;\r\n    } = storageService.getSessionItem(\r\n      RailEnterpriseSearch.STORAGE_SESSION_PARAMS\r\n    ) || {\r\n      query: {},\r\n      tempParams: {} as RailTempParams,\r\n      originalUserSearch: {} as RailTempParams\r\n    };\r\n\r\n    this.updateTempParams(this.searchService.makeRailQuery(data.tempParams));\r\n    this._originalUserSearch = data.originalUserSearch;\r\n\r\n    if (this._originalUserSearch && this._originalUserSearch.chosenSearchType) {\r\n      this.chosenSearchType = this._originalUserSearch.chosenSearchType;\r\n    }\r\n\r\n    if (searchService.shouldAddTravellerSubscription()) {\r\n      searchService.travellerInformation.subscribe(\r\n        (travellers: Traveller[]) => {\r\n          this.travellers = travellers;\r\n          const splitTravellers = this.helpers.selectedTravellers(\r\n            travellers,\r\n            ServiceType.Rail\r\n          );\r\n          this.tempParams.noOfAdults = splitTravellers.adults.length;\r\n          this.tempParams.noOfChildren = splitTravellers.children.length;\r\n          this.travellers = travellers;\r\n          this._isValid();\r\n        }\r\n      );\r\n    }\r\n    this._isValid();\r\n    const results =\r\n      storageService.getSessionItemAsList<RailQuoteResultArray>(\r\n        this.resultsSessionName\r\n      ) || [];\r\n    // if (results == null && this.isValid) {\r\n    //   searchService.startSearches();\r\n    // }\r\n    this._cheapestResultPrice = this.updateLowestPrice(results);\r\n    this.results.next(results || []);\r\n  }\r\n\r\n  protected resetQuery(): void {\r\n    this.updateTempParams(this.searchService.makeRailQuery());\r\n    this._isValid();\r\n  }\r\n\r\n  private _setAirportExpressStations() {\r\n    const parsedStation =\r\n      this.airportExpressStationsCodes[this.airportExpressStation];\r\n    console.log('--- Parsed Station is :', parsedStation);\r\n    if (parsedStation) {\r\n      this._travellingFrom = parsedStation.dep;\r\n      this._travellingTo = parsedStation.arr;\r\n    }\r\n  }\r\n\r\n  private _isValid() {\r\n    this.storageService.setSessionItem(\r\n      RailEnterpriseSearch.STORAGE_SESSION_PARAMS,\r\n      {\r\n        tempParams: this.tempParams,\r\n        originalUserSearch: this.originalUserSearch\r\n      }\r\n    );\r\n\r\n    this.validationMessages = [];\r\n\r\n    const now = moment();\r\n\r\n    if (!this._travellingFrom) {\r\n      this.validationMessages.push('Please Enter a From Location.');\r\n    }\r\n\r\n    if (!this._travellingTo) {\r\n      this.validationMessages.push('Please Enter a To Location.');\r\n    }\r\n\r\n    if (this.outBoundDateTime?.isBefore(now)) {\r\n      this.validationMessages.push(\r\n        'Departure Date/Time cannot be in the past.'\r\n      );\r\n    }\r\n\r\n    if (\r\n      this.chosenSearchType === RailJourneyType.ReturnJourney ||\r\n      this.chosenSearchType === RailJourneyType.DualSingleJourney\r\n    ) {\r\n      // check for return specific validations in here\r\n\r\n      if (this.inBoundDateTime?.isSameOrBefore(this.outBoundDateTime)) {\r\n        this.validationMessages.push(\r\n          'Return Date/Time must be after Departure Date/Time'\r\n        );\r\n      }\r\n    }\r\n\r\n    if (this.via) {\r\n      if (!this.tempParams.viaLocation) {\r\n        this.validationMessages.push('Please enter a via location.');\r\n      }\r\n    }\r\n\r\n    if (this.tempParams.noOfAdults + this.tempParams.noOfChildren < 1) {\r\n      this.validationMessages.push('There must be at least 1 traveller');\r\n    }\r\n\r\n    this.isValid.next(this.validationMessages.length === 0);\r\n    this.messages.next(this.validationMessages);\r\n  }\r\n\r\n  startSearch(): Promise<boolean> {\r\n    this.results.next([]);\r\n\r\n    if (this.isValid.value) {\r\n      this._originalUserSearch = Object.freeze({ ...this.tempParams });\r\n      this.storageService.setSessionItem(\r\n        RailEnterpriseSearch.STORAGE_SESSION_PARAMS,\r\n        {\r\n          tempParams: this.tempParams,\r\n          originalUserSearch: this.originalUserSearch\r\n        }\r\n      );\r\n      const query = this.getSearchQuery();\r\n      this.searchService.saveRecentSearch(this.getRecentSearchQuery(query));\r\n      return this._startSearch(\r\n        this.Railfetcher.fetchList(query).pipe(\r\n          map((result) => {\r\n            if (this.removePassingPointsFromResults) {\r\n              result = this._removeCallingPoints(result);\r\n            }\r\n\r\n            return result;\r\n          })\r\n        )\r\n      );\r\n    } else {\r\n      return Promise.resolve(false);\r\n    }\r\n  }\r\n\r\n  getRecentSearchQuery(\r\n    query: SearchRailQueryVariables\r\n  ): SaveRecentSearchMutationVariables {\r\n    const recentSearchQuery: RailRecentSearchArgs = query;\r\n    \r\n    if (this.isAirportExpress) {\r\n      recentSearchQuery.isAirportExpress = this.isAirportExpress;\r\n    }\r\n\r\n    if (this.airportExpressStation) {\r\n      recentSearchQuery.airportExpressStation = this.airportExpressStation;\r\n    }\r\n\r\n    return {\r\n      serviceType: ServiceType.Rail,\r\n      searchArgs: recentSearchQuery,\r\n      travelDate: this.outBoundDateTime.format(),\r\n      travellers: this.helpers.getTravellersId(this.travellers)\r\n    };\r\n  }\r\n\r\n  public startRecentSearch(recentSearch: RecentSearch): void {\r\n    this.chosenSearchType = recentSearch.searchArgs.journeyType;\r\n    this.chosenSearchClass = recentSearch.searchArgs.class;\r\n    this.extraTime = recentSearch.searchArgs.extraTimeToChange;\r\n    this.isAirportExpress = recentSearch.searchArgs.isAirportExpress;\r\n    this.airportExpressStation = recentSearch.searchArgs.airportExpressStation;\r\n\r\n    // get outBoundDateTime, inBoundDateTime and outboundCriteria ,returnCriteria\r\n    this.outBoundDateTime = recentSearch.searchArgs.outboundDepartureDateTime\r\n      ? moment(recentSearch.searchArgs.outboundDepartureDateTime)\r\n      : moment(recentSearch.searchArgs.outboundArrivalDateTime);\r\n    this.outboundCriteria = this.getCriteria(\r\n      recentSearch.searchArgs.outboundDepartureDateTime,\r\n      recentSearch.searchArgs.outboundArrivalDateTime\r\n    );\r\n\r\n    if (recentSearch.searchArgs.journeyType === RailJourneyType.ReturnJourney) {\r\n      this.inBoundDateTime = recentSearch.searchArgs.returnDepartureDateTime\r\n        ? moment(recentSearch.searchArgs.returnDepartureDateTime)\r\n        : moment(recentSearch.searchArgs.returnArrivalDateTime);\r\n\r\n      this.returnCriteria = this.getCriteria(\r\n        recentSearch.searchArgs.returnDepartureDateTime,\r\n        recentSearch.searchArgs.returnArrivalDateTime\r\n      );\r\n    }\r\n\r\n    if (\r\n      recentSearch.searchArgs.journeyType === RailJourneyType.OpenReturnJourney\r\n    ) {\r\n      this.openReturn = true;\r\n    }\r\n\r\n    this.applyRailcards = recentSearch.searchArgs?.railCardQualifiers?.length\r\n      ? true\r\n      : false;\r\n    if (this.applyRailcards) {\r\n      this.railCards = recentSearch.searchArgs.railCardQualifiers;\r\n    }\r\n\r\n    // get from, to, via\r\n    combineLatest([\r\n      this.getRailStationById(recentSearch.searchArgs.departureLocationId),\r\n      this.getRailStationById(recentSearch.searchArgs.arrivalLocationId)\r\n    ]).subscribe(([departureStation, arrivalStation]) => {\r\n      if (departureStation && arrivalStation) {\r\n        this.travellingTo = {\r\n          name: arrivalStation.name,\r\n          railstation: {\r\n            id: arrivalStation.id,\r\n            name: arrivalStation.name,\r\n            nlcCode: arrivalStation.nlcCode,\r\n            stationCode: arrivalStation.stationCode,\r\n            trainlineCode: arrivalStation.trainlineCode,\r\n            trainlineUniqueCode: arrivalStation.trainlineUniqueCode\r\n          }\r\n        };\r\n\r\n        this.travellingFrom = {\r\n          name: departureStation.name,\r\n          railstation: {\r\n            id: departureStation.id,\r\n            name: departureStation.name,\r\n            nlcCode: departureStation.nlcCode,\r\n            stationCode: departureStation.stationCode,\r\n            trainlineCode: departureStation.trainlineCode,\r\n            trainlineUniqueCode: departureStation.trainlineUniqueCode\r\n          }\r\n        };\r\n\r\n        if (recentSearch.searchArgs.viaLocationId) {\r\n          this.via = true;\r\n          this.getRailStationById(\r\n            recentSearch.searchArgs.viaLocationId\r\n          ).subscribe((viaLocation) => {\r\n            this.viaLocation = {\r\n              name: viaLocation.name,\r\n              railstation: {\r\n                id: viaLocation.id,\r\n                name: viaLocation.name,\r\n                nlcCode: viaLocation.nlcCode,\r\n                stationCode: viaLocation.stationCode,\r\n                trainlineCode: viaLocation.trainlineCode,\r\n                trainlineUniqueCode: viaLocation.trainlineUniqueCode\r\n              }\r\n            };\r\n            this.searchService.startSearches();\r\n          });\r\n        }\r\n\r\n        this.searchService.startSearches();\r\n      }\r\n    });\r\n  }\r\n\r\n  private _removeCallingPoints(\r\n    journeys: RailJourneyOptions[]\r\n  ): RailJourneyOptions[] {\r\n    journeys[0].outbound = journeys[0].outbound.map((outbound) => {\r\n      outbound.segments.map((segment) => {\r\n        segment.callingPoints = segment.callingPoints.filter(\r\n          (callingPoint) =>\r\n            callingPoint.stoppingPattern !== RailEnterpriseSearch.PASSING_POINT\r\n        );\r\n        return segment;\r\n      });\r\n      return outbound;\r\n    });\r\n\r\n    return journeys;\r\n  }\r\n\r\n  private _updateOutboundDateTime(): void {\r\n    if (this._outbound_date && this._outbound_time) {\r\n      const time = this.helpers.ngDateToMoment(\r\n        this._outbound_date,\r\n        this._outbound_time\r\n      );\r\n      this.outBoundDateTime = time.isValid() ? time : null;\r\n      this._isValid();\r\n    }\r\n  }\r\n\r\n  private _updateReturnDateTime(): void {\r\n    if (this._return_date && this._return_time) {\r\n      const time = this.helpers.ngDateToMoment(\r\n        this._return_date,\r\n        this._return_time\r\n      );\r\n      this.inBoundDateTime = time.isValid() ? time : null;\r\n      this._isValid();\r\n    }\r\n  }\r\n\r\n  getSearchQuery(): SearchRailQueryVariables {\r\n    const query: SearchRailQueryVariables = {\r\n      countryCode: 'GB',\r\n      journeyType: this.tempParams.chosenSearchType,\r\n      adults: this.tempParams.noOfAdults,\r\n      arrivalLocationId: this._travellingTo,\r\n      departureLocationId: this._travellingFrom,\r\n      children: this.tempParams.noOfChildren,\r\n      class: this.tempParams.chosenSearchClass,\r\n      extraTimeToChange: this.tempParams.extraTime,\r\n      outboundArrivalDateTime: this.tempParams.outBoundDateTime,\r\n      outboundDepartureDateTime: this.tempParams.outBoundDateTime,\r\n      returnArrivalDateTime: this.tempParams.inBoundDateTime,\r\n      returnDepartureDateTime: this.tempParams.inBoundDateTime,\r\n      viaLocationId: this._viaLocation,\r\n      railCardQualifiers: this.tempParams.railCards?.map(\r\n        (railCard: ReferenceRailCardQualifier) => {\r\n          return railCard.code;\r\n        }\r\n      )\r\n    };\r\n\r\n    if (this.tempParams.noOfChildren === 0) {\r\n      query.children = null;\r\n    }\r\n\r\n    if (this._viaLocation === '') {\r\n      query.viaLocationId = null;\r\n    }\r\n\r\n    switch (this.tempParams.outboundCriteria) {\r\n      case RailSearchCriteria.Depart:\r\n        query.outboundArrivalDateTime = null;\r\n        break;\r\n      case RailSearchCriteria.Arrive:\r\n        query.outboundDepartureDateTime = null;\r\n        break;\r\n      default:\r\n        console.warn(\r\n          `+++ Unknown Criteria: ${this.tempParams.outboundCriteria} +++`\r\n        );\r\n    }\r\n\r\n    switch (this.tempParams.returnCriteria) {\r\n      case RailSearchCriteria.Depart:\r\n        query.returnArrivalDateTime = null;\r\n        break;\r\n      case RailSearchCriteria.Arrive:\r\n        query.returnDepartureDateTime = null;\r\n        break;\r\n      default:\r\n        console.warn(\r\n          `+++ Unknown Criteria: ${this.tempParams.returnCriteria} +++`\r\n        );\r\n    }\r\n\r\n    switch (this.tempParams.chosenSearchType) {\r\n      case RailJourneyType.SingleJourney:\r\n      case RailJourneyType.OpenReturnJourney:\r\n        query.returnDepartureDateTime = null;\r\n        query.returnArrivalDateTime = null;\r\n        break;\r\n    }\r\n\r\n    return this.helpers.removeNulls<SearchRailQueryVariables>(query);\r\n  }\r\n\r\n  private getRailStationById(id: string): Observable<RailStation> {\r\n    if (id) {\r\n      return this.getRailStationFetcher.fetchList({ id }).pipe(take(1));\r\n    } else {\r\n      return of();\r\n    }\r\n  }\r\n\r\n  private getCriteria(\r\n    departureDateTime: string,\r\n    arrivalDateTime: string\r\n  ): RailSearchCriteria {\r\n    if (departureDateTime) {\r\n      return RailSearchCriteria.Depart;\r\n    } else if (arrivalDateTime) {\r\n      return RailSearchCriteria.Arrive;\r\n    }\r\n    {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  createTicketGroups(results: RailJourneyOptions[]): RailTicketGroups {\r\n    let tickets: RailTicketGroups = {};\r\n    let ticketId = '';\r\n    this._canCombine = {};\r\n\r\n    let ticketGroupsOutbound = this.setTicketsGroups(results[0].outbound);\r\n    let ticketGroupsReturn = this.setTicketsGroups(results[0].return);\r\n    ticketGroupsOutbound = this.sortTicketPrices(ticketGroupsOutbound);\r\n    ticketGroupsReturn = this.sortTicketPrices(ticketGroupsReturn);\r\n\r\n    Object.keys(ticketGroupsOutbound).map((key) => {\r\n      ticketGroupsOutbound[key].map((tkt: RailTicketOption) => {\r\n        ticketId = `${tkt.type}${tkt.singleOrReturn}`;\r\n        const identifier = tkt.identifiers.journeyIdentifier;\r\n        const identifierObj: RailResultIndifiers = {};\r\n        identifierObj[identifier] = {\r\n          price: tkt.price,\r\n          isChild: false,\r\n          fareIdentifier: tkt.identifiers.fareIdentifier,\r\n          availableSeats: tkt.availableSeats\r\n        };\r\n        if (tickets[key]) {\r\n          this.updateCanCombine(tkt);\r\n          identifierObj[tkt.identifiers.journeyIdentifier].isChild = false;\r\n          if (tickets[tkt.type].header.price === tkt.price) {\r\n            tickets[tkt.type].resultIndifiers.push(identifier);\r\n            tickets[tkt.type].resultIndifiersPrices = {\r\n              ...tickets[tkt.type].resultIndifiersPrices,\r\n              ...identifierObj\r\n            };\r\n          } else if (tkt.price) {\r\n            // add identifier and price even if it is a child\r\n            if (!tickets[tkt.type].resultIndifiers.includes(identifier)) {\r\n              tickets[tkt.type].resultIndifiers.push(identifier);\r\n              tickets[tkt.type].resultIndifiersPrices = {\r\n                ...tickets[tkt.type].resultIndifiersPrices,\r\n                ...identifierObj\r\n              };\r\n            }\r\n            identifierObj[identifier].isChild = true;\r\n            const childTicket = {\r\n              header: tkt,\r\n              children: [],\r\n              open: false,\r\n              direction: RailDirection.Outbound,\r\n              resultIndifiers: [identifier],\r\n              resultIndifiersPrices: identifierObj,\r\n              child: true,\r\n              ticketId,\r\n              selectedIndicies: [],\r\n              disabledIndicies: [],\r\n              showLimitedSeats: false\r\n            } as RailTicketGroup;\r\n            tickets[tkt.type].children.push(childTicket);\r\n          }\r\n        } else {\r\n          this._canCombine[tkt.type] = {};\r\n          this.updateCanCombine(tkt);\r\n          tickets[tkt.type] = {\r\n            header: tkt,\r\n            children: [],\r\n            open: false,\r\n            direction: RailDirection.Outbound,\r\n            resultIndifiers: [identifier],\r\n            resultIndifiersPrices: identifierObj,\r\n            child: false,\r\n            ticketId,\r\n            selectedIndicies: [],\r\n            disabledIndicies: [],\r\n            showLimitedSeats: false\r\n          } as RailTicketGroup;\r\n        }\r\n      });\r\n    });\r\n\r\n    Object.keys(ticketGroupsReturn).map((key) => {\r\n      ticketGroupsReturn[key].map((tkt: RailTicketOption) => {\r\n        ticketId = `${tkt.type}${tkt.singleOrReturn}`;\r\n        const identifier = tkt.identifiers.journeyIdentifier;\r\n        const identifierObj: RailResultIndifiers = {};\r\n        identifierObj[identifier] = {\r\n          price: tkt.price,\r\n          isChild: true,\r\n          fareIdentifier: tkt.identifiers.fareIdentifier,\r\n          availableSeats: tkt.availableSeats\r\n        };\r\n        if (\r\n          tickets[tkt.type] &&\r\n          tkt.price &&\r\n          tkt.price !== tickets[tkt.type].header.price\r\n        ) {\r\n          this.updateCanCombine(tkt);\r\n          identifierObj[identifier].isChild = true;\r\n          const childTicket = {\r\n            header: tkt,\r\n            children: [],\r\n            open: false,\r\n            direction: RailDirection.Inbound,\r\n            resultIndifiers: [identifier],\r\n            resultIndifiersPrices: identifierObj,\r\n            child: true,\r\n            ticketId,\r\n            selectedIndicies: [],\r\n            disabledIndicies: [],\r\n            showLimitedSeats: false\r\n          } as any;\r\n          tickets[tkt.type].children.push(childTicket);\r\n        } else if (!tickets[tkt.type]) {\r\n          this.updateCanCombine(tkt);\r\n          tickets[tkt.type] = {\r\n            header: tkt,\r\n            children: [],\r\n            open: false,\r\n            direction: RailDirection.Inbound,\r\n            resultIndifiers: [identifier],\r\n            resultIndifiersPrices: identifierObj,\r\n            child: false,\r\n            ticketId,\r\n            selectedIndicies: [],\r\n            disabledIndicies: [],\r\n            showLimitedSeats: false\r\n          } as any;\r\n        } else if (!tkt.price || tkt.price === tickets[tkt.type].header.price) {\r\n          this.updateCanCombine(tkt);\r\n          tickets[tkt.type].resultIndifiers.push(identifier);\r\n          identifierObj[identifier].isChild = false;\r\n          tickets[tkt.type].resultIndifiersPrices = {\r\n            ...tickets[tkt.type].resultIndifiersPrices,\r\n            ...identifierObj\r\n          };\r\n        }\r\n      });\r\n    });\r\n\r\n    let combineTickets = { ...tickets };\r\n    tickets = this.combineChildTickets(combineTickets);\r\n\r\n    // console.log('groups: ', tickets);\r\n    // console.log('Can Combine: ', this._canCombine);\r\n    return tickets;\r\n  }\r\n\r\n  combineChildTickets(tickets: RailTicketGroups): RailTicketGroups {\r\n    const values = Object.values(tickets);\r\n    for (let i = 0; i < values.length; i++) {\r\n      const childObject: { [key: string]: RailTicketGroup } = {};\r\n\r\n      for (let j = 0; j < values[i].children.length; j++) {\r\n        const child = values[i].children[j];\r\n        const fareIdentifier = child.header.identifiers.fareIdentifier;\r\n        if (childObject[fareIdentifier]) {\r\n          childObject[fareIdentifier].resultIndifiers.push(\r\n            child.resultIndifiers[0]\r\n          );\r\n          childObject[fareIdentifier].resultIndifiersPrices = {\r\n            ...childObject[fareIdentifier].resultIndifiersPrices,\r\n            ...child.resultIndifiersPrices\r\n          };\r\n        } else {\r\n          childObject[fareIdentifier] = child;\r\n        }\r\n      }\r\n      // console.log(childObject);\r\n      // console.log(values[i]['header']['type']);\r\n      tickets[values[i].header.type].children = Object.values(childObject);\r\n    }\r\n    tickets = this.sortTicketChildrenPrices(tickets);\r\n    return tickets;\r\n  }\r\n  setTicketsGroups(results: RailJourneyOption[]): TicketGroups {\r\n    let ticketGroups: TicketGroups = {};\r\n    results.forEach((out: RailJourneyOption) => {\r\n      out.providers.forEach((prov: RailProvider) => {\r\n        prov.ticketOptions.forEach((tkt: RailTicketOption) => {\r\n          ticketGroups[tkt.type]\r\n            ? ticketGroups[tkt.type].push(tkt)\r\n            : (ticketGroups[tkt.type] = [tkt]);\r\n        });\r\n      });\r\n    });\r\n    return ticketGroups;\r\n  }\r\n\r\n  updateFromPreviousSearches(\r\n    previousItems: Record<ServiceType, BasketItem>\r\n  ): void {}\r\n\r\n  updateCanCombine(tkt: RailTicketOption): void {\r\n    (tkt.identifiers.allowedWith || []).forEach((allowed) => {\r\n      if (!this._canCombine[tkt.type][allowed.journeyIdentifier]) {\r\n        this._canCombine[tkt.type][allowed.journeyIdentifier] = [\r\n          allowed.fareIdentifier\r\n        ];\r\n      } else {\r\n        this._canCombine[tkt.type][allowed.journeyIdentifier].push(\r\n          allowed.fareIdentifier\r\n        );\r\n      }\r\n    });\r\n  }\r\n\r\n  toggleTicketSelect(\r\n    ticket: RailTicketGroup,\r\n    way: 'departs' | 'returns',\r\n    timeSlotId: string,\r\n    ticketId: string,\r\n    fareIdentifier: string,\r\n    ticketsGroups: RailTicketGroups\r\n  ): RailTicketGroups {\r\n    console.log(ticket);\r\n\r\n    if (!ticket) {\r\n      return;\r\n    }\r\n\r\n    this._chosenTicketGroup = ticket;\r\n    const keys = Object.keys(ticketsGroups);\r\n    let selectedTicket = null;\r\n    let departsTicket: RailTicketOption[] = [];\r\n    let returnTicket: RailTicketOption[] = [];\r\n    let isUnselected = false;\r\n    keys.forEach((key) => {\r\n      let group = ticketsGroups[key] as RailTicketGroup;\r\n\r\n      if (\r\n        group.ticketId === ticketId &&\r\n        group.selectedIndicies.includes(timeSlotId)\r\n      ) {\r\n        if (way === 'departs') {\r\n          group.selectedIndicies = [];\r\n          departsTicket = [];\r\n          returnTicket = [];\r\n          this._chosenInboundTicket = null;\r\n          this._chosenInboundJourney = null;\r\n          this._chosenTicketGroup = null;\r\n          group.children.forEach((child) => {\r\n            child.selectedIndicies = [];\r\n          });\r\n        } else {\r\n          group.selectedIndicies = group.selectedIndicies.filter(\r\n            (Indicies) => Indicies !== timeSlotId\r\n          );\r\n          returnTicket = returnTicket.filter(\r\n            (Indicies) => Indicies !== group.header\r\n          );\r\n        }\r\n      } else {\r\n        if (\r\n          group.ticketId === ticketId &&\r\n          group.header.identifiers.fareIdentifier === fareIdentifier &&\r\n          way === 'departs'\r\n        ) {\r\n          group = this.clearUnneededTickets(way, group, timeSlotId);\r\n          group.selectedIndicies.push(timeSlotId);\r\n          way === 'departs'\r\n            ? departsTicket.push(group.header)\r\n            : returnTicket.push(group.header);\r\n          selectedTicket = group.header;\r\n        } else {\r\n          // may have to modify this for dual singles\r\n          if (way === 'departs') {\r\n            group.selectedIndicies = [];\r\n          } else if (ticketId.includes(group.header.type)) {\r\n            selectedTicket = group.header;\r\n          }\r\n        }\r\n\r\n        group.children.forEach((child) => {\r\n          if (child.selectedIndicies.includes(timeSlotId)) {\r\n            if (way === 'departs') {\r\n              child.selectedIndicies = [];\r\n              departsTicket = [];\r\n              returnTicket = [];\r\n              this._chosenInboundTicket = null;\r\n              this._chosenInboundJourney = null;\r\n              isUnselected = true;\r\n            } else {\r\n              child.selectedIndicies = child.selectedIndicies.filter(\r\n                (Indicies) => Indicies !== timeSlotId\r\n              );\r\n              returnTicket = returnTicket.filter(\r\n                (Indicies) => Indicies !== group.header\r\n              );\r\n            }\r\n          } else {\r\n            if (\r\n              child.ticketId === ticketId &&\r\n              child.header.identifiers.fareIdentifier === fareIdentifier\r\n            ) {\r\n              if (\r\n                (way === 'departs' &&\r\n                  child.direction !== RailDirection.Inbound) ||\r\n                (way !== 'departs' && child.direction === RailDirection.Inbound)\r\n              ) {\r\n                child = this.clearUnneededTickets(way, child, timeSlotId);\r\n                child.selectedIndicies.push(timeSlotId);\r\n                way === 'departs'\r\n                  ? departsTicket.push(child.header)\r\n                  : returnTicket.push(child.header);\r\n                selectedTicket = child.header;\r\n              } else if (isUnselected) {\r\n                child.selectedIndicies = [];\r\n              }\r\n            } else {\r\n              child.selectedIndicies = [];\r\n            }\r\n          }\r\n        });\r\n      }\r\n    });\r\n\r\n    // now we need to mark tickets as disabled if they are returns that do not match the selected return\r\n    // or on overlapping times\r\n    if (way === 'departs') {\r\n      this._chosenOutboundTicket = this.helpers.clone(selectedTicket);\r\n\r\n      // now go over the full results and find the matching timeslot\r\n      departsTicket.length\r\n        ? (this._chosenOutboundJourney = this.results.value[0].outbound.find(\r\n            (out: RailJourneyOption) => {\r\n              return out.identifiers.journeyIdentifier === timeSlotId;\r\n            }\r\n          ))\r\n        : (this._chosenOutboundJourney = null);\r\n\r\n      if (\r\n        this._chosenInboundTicket &&\r\n        this._chosenOutboundTicket.singleOrReturn ===\r\n          RailTicketOptionType.Return &&\r\n        this._chosenOutboundTicket.identifiers.fareIdentifier !==\r\n          this._chosenInboundTicket.identifiers.fareIdentifier\r\n      ) {\r\n        console.warn('+++ Cannot combine fares, clearing inbound... +++');\r\n        this._chosenInboundTicket = null;\r\n        this._chosenInboundJourney = null;\r\n      }\r\n    } else if (way === 'returns') {\r\n      this._chosenInboundTicket = this.helpers.clone(selectedTicket);\r\n\r\n      this._chosenInboundTicket\r\n        ? (this._chosenInboundJourney = this.results.value[0].return.find(\r\n            (inT: RailJourneyOption) => {\r\n              return inT.identifiers.journeyIdentifier === timeSlotId;\r\n            }\r\n          ))\r\n        : (this._chosenInboundJourney = null);\r\n    }\r\n\r\n    return ticketsGroups;\r\n  }\r\n\r\n  /**\r\n   * @description - determine if a fare can be combined with what we currently have selected\r\n   */\r\n  canCombine(journeyIdentifier: string, fareIdentifier: string): boolean {\r\n    // may have to modify this for dual singles later on\r\n    try {\r\n      if (\r\n        this._chosenOutboundTicket &&\r\n        this._chosenOutboundTicket.singleOrReturn ===\r\n          RailTicketOptionType.Return &&\r\n        Number(journeyIdentifier) > 5\r\n      ) {\r\n        // greater than 5 only as we are not going to restrict outbounds\r\n        if (\r\n          this._canCombine[this._chosenOutboundTicket.type][\r\n            Number(journeyIdentifier)\r\n          ]?.includes(fareIdentifier) &&\r\n          this._chosenOutboundTicket.identifiers.fareIdentifier ===\r\n            fareIdentifier\r\n        ) {\r\n          return true;\r\n        }\r\n        return false;\r\n      }\r\n    } catch (error) {\r\n      console.error('+++ Error combining rail fares: ', error, ' +++');\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  clearUnneededTickets(\r\n    way: string,\r\n    group: RailTicketGroup,\r\n    timeSlotId: string\r\n  ): RailTicketGroup {\r\n    if (way === 'returns') {\r\n      group.selectedIndicies = group.selectedIndicies.filter(\r\n        (indicie: string) => {\r\n          return Number(indicie) <= 5 || indicie === timeSlotId;\r\n        }\r\n      );\r\n    } else {\r\n      group.selectedIndicies = group.selectedIndicies.filter(\r\n        (indicie: string) => {\r\n          return Number(indicie) > 5 || indicie === timeSlotId;\r\n        }\r\n      );\r\n    }\r\n\r\n    return group;\r\n  }\r\n\r\n  getRailStation(\r\n    code: string,\r\n    isLoading?: BehaviorSubject<boolean>\r\n  ): Observable<RailStation> {\r\n    if (code.length === 3) {\r\n      isLoading?.next(true);\r\n      return this.getRailStationFetcher.fetchList({ code }).pipe(\r\n        tap(() => isLoading?.next(false)),\r\n        take(1)\r\n      );\r\n    } else {\r\n      return of();\r\n    }\r\n  }\r\n\r\n  getSelectedRailTicketOption(\r\n    railJourneyOption: RailJourneyOption,\r\n    railTicketGroup: RailTicketGroup,\r\n    providerIndex: number\r\n  ): RailTicketOption {\r\n    return railJourneyOption.providers[providerIndex].ticketOptions.find(\r\n      (ticketOption) =>\r\n        ticketOption.type === railTicketGroup.header.type &&\r\n        (ticketOption.price === railTicketGroup.header.price ||\r\n          ticketOption.identifiers.fareIdentifier ===\r\n            railTicketGroup.header.identifiers.fareIdentifier)\r\n    );\r\n  }\r\n\r\n  getLegsFromRailJourneyOption(railJourneyOption: RailJourneyOption): any[] {\r\n    let legs: any[] = [];\r\n    if (railJourneyOption?.segments.length) {\r\n      legs = railJourneyOption.segments.map((segment) => {\r\n        return {\r\n          operator: segment.operator,\r\n          departureDateTime: segment.departDateTime,\r\n          departureStationName: segment.depart,\r\n          arrivalDateTime: segment.arriveDateTime,\r\n          arrivalStationName: segment.arrive\r\n        };\r\n      });\r\n    }\r\n    return legs;\r\n  }\r\n\r\n  async addSingleJourneyToBasket(\r\n    serviceId: string,\r\n    railQuery: SearchRailQueryVariables,\r\n    railJourneyOption: RailJourneyOption,\r\n    railTicketGroup: RailTicketGroup\r\n  ): Promise<boolean> {\r\n\r\n    let outTicketExtras: TicketExtras[];\r\n    // if ticketExtras exists create TicketExtrasObject and added it to the basket\r\n    if (railJourneyOption.ticketExtras) {\r\n      outTicketExtras = this.createTicketExtrasObject(railJourneyOption.ticketExtras[0]);\r\n    }\r\n    \r\n    if (railJourneyOption.unsellable) {\r\n      return Promise.resolve(false);\r\n    }\r\n    const intBasket: InternalBasketInterface =\r\n      await this.basketService.getDefaultBasket();\r\n    const basket = intBasket?.subject.value;\r\n    if (basket) {\r\n      const selectedRailTicketOption = this.getSelectedRailTicketOption(\r\n        railJourneyOption,\r\n        railTicketGroup,\r\n        0\r\n      );\r\n      const legs = this.getLegsFromRailJourneyOption(railJourneyOption);\r\n      const ticketQueueList = selectedRailTicketOption.ticketQueueList.map(\r\n        (ticketQueueList1) => {\r\n          return {\r\n            id: ticketQueueList1.id,\r\n            name: ticketQueueList1.name,\r\n            type: ticketQueueList1.type\r\n          };\r\n        }\r\n      );\r\n\r\n      const basketItem: RailBasketItem = {\r\n        basket: basket.id,\r\n        service: serviceId,\r\n        detail: {\r\n          accountsList: selectedRailTicketOption.accountsList.map(\r\n            (account: RailAccount) => {\r\n              return { id: account.id, description: account.description };\r\n            }\r\n          ),\r\n          outwardDetail: {\r\n            arrivalDateTime: railJourneyOption.arriveDateTime,\r\n            arrivalStationName: railJourneyOption.to,\r\n            departureDateTime: railJourneyOption.departDateTime,\r\n            departureStationName: railJourneyOption.from,\r\n            supplierTickets: [\r\n              {\r\n                supplierName: railJourneyOption.providers[0].name,\r\n                ticketDescription: selectedRailTicketOption.type,\r\n                price: selectedRailTicketOption.price,\r\n                legs\r\n              }\r\n            ]\r\n          },\r\n          transactionIdentifier:\r\n            railJourneyOption.identifiers.transactionIdentifier,\r\n          outbound: {\r\n            fareIdentifiers: [\r\n              selectedRailTicketOption.identifiers.fareIdentifier\r\n            ],\r\n            journeyIdentifier: selectedRailTicketOption.identifiers.journeyIdentifier\r\n          },\r\n          ticketQueueList\r\n        },\r\n        adults: railQuery.adults,\r\n        price: selectedRailTicketOption.price,\r\n        currency: selectedRailTicketOption.currency as CurrencyCode,\r\n        searchQuery: railQuery,\r\n        co2PerItem: railJourneyOption.co2PerItem,\r\n        co2PerPassenger: railJourneyOption.co2PerPassenger,\r\n        outboundDate: railJourneyOption.departDateTime\r\n      }\r\n\r\n      // if outTicketExtras exists add the object to basketItem\r\n      if (outTicketExtras) {\r\n        basketItem.detail.outbound.ticketExtras = outTicketExtras;\r\n      }\r\n\r\n      return this.basketService.addToBasket(\r\n        basketItem,\r\n        intBasket,\r\n        this.searchService,\r\n        this.travellers\r\n      );\r\n    }\r\n    return Promise.resolve(false);\r\n  }\r\n\r\n  async addReturnJourneyToBasket(\r\n    serviceId: string,\r\n    railQuery: SearchRailQueryVariables,\r\n    outbound: RailJourneyOption,\r\n    inbound: RailJourneyOption,\r\n    railTicketGroup: RailTicketGroup\r\n  ): Promise<boolean> {\r\n    if (outbound.unsellable) {\r\n      return Promise.resolve(false);\r\n    }\r\n\r\n    let inTicketExtras: TicketExtras[];\r\n    let outTicketExtras: TicketExtras[];\r\n\r\n    // if ticketExtras exists create TicketExtrasObject and added it to the basket\r\n    if (inbound.ticketExtras) {\r\n      inTicketExtras = this.createTicketExtrasObject(inbound.ticketExtras[0]);\r\n    }\r\n\r\n    if (outbound.ticketExtras) {\r\n      outTicketExtras = this.createTicketExtrasObject(outbound.ticketExtras[0]);\r\n    }\r\n\r\n    const intBasket: InternalBasketInterface =\r\n      await this.basketService.getDefaultBasket();\r\n    const basket = intBasket?.subject.value;\r\n    if (basket) {\r\n      const selectedRailTicketOption = this.getSelectedRailTicketOption(\r\n        outbound,\r\n        railTicketGroup,\r\n        0\r\n      );\r\n      const selectedInboundRailTicketOption = this.getSelectedRailTicketOption(\r\n        inbound,\r\n        railTicketGroup,\r\n        0\r\n      );\r\n      const outboundLegs = this.getLegsFromRailJourneyOption(outbound);\r\n      const inboundLegs = this.getLegsFromRailJourneyOption(inbound);\r\n      const ticketQueueList = selectedRailTicketOption.ticketQueueList.map(\r\n        (ticketQueueList1: RailTicketQueue) => {\r\n          return {\r\n            id: ticketQueueList1.id,\r\n            name: ticketQueueList1.name,\r\n            type: ticketQueueList1.type\r\n          };\r\n        }\r\n      );\r\n\r\n      const basketItem: RailBasketItem = {\r\n        basket: basket.id,\r\n        service: serviceId,\r\n        detail: {\r\n          accountsList: selectedRailTicketOption.accountsList.map(\r\n            (account: RailAccount) => {\r\n              return { id: account.id, description: account.description };\r\n            }\r\n          ),\r\n          outwardDetail: {\r\n            arrivalDateTime: outbound.arriveDateTime,\r\n            arrivalStationName: outbound.to,\r\n            departureDateTime: outbound.departDateTime,\r\n            departureStationName: outbound.from,\r\n            supplierTickets: [\r\n              {\r\n                supplierName: outbound.providers[0].name,\r\n                ticketDescription: selectedRailTicketOption.type,\r\n                price: selectedRailTicketOption.price,\r\n                legs: outboundLegs\r\n              }\r\n            ]\r\n          },\r\n          inwardDetail: {\r\n            arrivalDateTime: inbound.arriveDateTime,\r\n            arrivalStationName: inbound.to,\r\n            departureDateTime: inbound.departDateTime,\r\n            departureStationName: inbound.from,\r\n            supplierTickets: [\r\n              {\r\n                supplierName: inbound.providers[0].name,\r\n                ticketDescription: selectedRailTicketOption.type,\r\n                legs: inboundLegs\r\n              }\r\n            ]\r\n          },\r\n          transactionIdentifier: outbound.identifiers.transactionIdentifier,\r\n          outbound: {\r\n            fareIdentifiers: [\r\n              selectedRailTicketOption.identifiers.fareIdentifier\r\n            ],\r\n            journeyIdentifier: selectedRailTicketOption.identifiers.journeyIdentifier\r\n          },\r\n          ticketQueueList,\r\n          return: {\r\n            fareIdentifiers: [\r\n              selectedInboundRailTicketOption.identifiers.fareIdentifier\r\n            ],\r\n            journeyIdentifier: selectedInboundRailTicketOption.identifiers.journeyIdentifier\r\n          }\r\n        },\r\n        adults: railQuery.adults,\r\n        price: railTicketGroup.header.price,\r\n        currency: selectedRailTicketOption.currency as CurrencyCode,\r\n        searchQuery: railQuery,\r\n        co2PerItem: outbound.co2PerItem,\r\n        co2PerPassenger: outbound.co2PerPassenger,\r\n        outboundDate: outbound.arriveDateTime,\r\n        inboundDate: inbound.arriveDateTime\r\n      }\r\n\r\n      // if inTicketExtras or outTicketExtras exists add the object to basketItem\r\n      if (inTicketExtras) {\r\n        basketItem.detail.return.ticketExtras = inTicketExtras;\r\n      }\r\n      if (outTicketExtras) {\r\n        basketItem.detail.outbound.ticketExtras = outTicketExtras;\r\n      }\r\n\r\n      return this.basketService.addToBasket(\r\n        basketItem,\r\n        intBasket,\r\n        this.searchService,\r\n        this.travellers\r\n      );\r\n    }\r\n    return Promise.resolve(false);\r\n  }\r\n\r\n  createTicketExtrasObject(railTicketExtra: RailTicketExtra): TicketExtras[] {\r\n    return [{\r\n      type: railTicketExtra.description,\r\n      location: railTicketExtra.location,\r\n      date: railTicketExtra.date\r\n    }];\r\n  }\r\n\r\n  sortTicketPrices(tickets: TicketGroups): TicketGroups {\r\n    const sortTicketPrices = { ...tickets };\r\n    Object.keys(sortTicketPrices).map((key) => {\r\n      sortTicketPrices[key].sort((a: RailTicketOption, b: RailTicketOption) => {\r\n        const priceA = a.price;\r\n        const priceB = b.price;\r\n        return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;\r\n      });\r\n    });\r\n    return sortTicketPrices;\r\n  }\r\n  sortTicketChildrenPrices(tickets: RailTicketGroups): RailTicketGroups {\r\n    const sortTicketPrices = { ...tickets };\r\n    Object.keys(sortTicketPrices).map((key) => {\r\n      sortTicketPrices[key].children.sort(\r\n        (a: RailTicketGroup, b: RailTicketGroup) => {\r\n          const priceA = a.header.price;\r\n          const priceB = b.header.price;\r\n          return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;\r\n        }\r\n      );\r\n    });\r\n    return sortTicketPrices;\r\n  }\r\n  updateLowestPrice(results: RailJourneyOptions[]): ICheapestPrice {\r\n    if (!results.length) return null;\r\n    let currency;\r\n    try {\r\n      currency = results[0].outbound[0].providers[0].ticketOptions[0].currency;\r\n    } catch (error) {\r\n      currency = 'GBP';\r\n    }\r\n\r\n    const price = this.findCheapestTicket(results);\r\n    return {\r\n      amount: price,\r\n      currencyCode: currency\r\n    };\r\n  }\r\n  findCheapestTicket(results: RailJourneyOptions[]): number {\r\n    this._cheapestFirst = null;\r\n    this._cheapestStandard = null;\r\n    if (!results.length) return null;\r\n    let cheapestArr: number[] = [];\r\n\r\n    results.map((result) => {\r\n      result.outbound.map((out) => {\r\n        out.providers.map((tkt) => {\r\n          let cheapestTicket: number = tkt.ticketOptions[0].price;\r\n          tkt.ticketOptions.map((tktOption) => {\r\n            let tktPrice = tktOption.price;\r\n            let tktClass = tktOption.class;\r\n            if (\r\n              tktClass === 'First' &&\r\n              (this._cheapestFirst?.price > tktPrice || !this._cheapestFirst)\r\n            ) {\r\n              this._cheapestFirst = tktOption;\r\n            } else if (\r\n              tktClass === 'Standard' &&\r\n              (this._cheapestStandard?.price > tktPrice ||\r\n                !this._cheapestStandard)\r\n            ) {\r\n              this._cheapestStandard = tktOption;\r\n            }\r\n            if (tktPrice === cheapestTicket) {\r\n              cheapestArr.push(cheapestTicket);\r\n            }\r\n          });\r\n        });\r\n      });\r\n    });\r\n    return Math.min(...cheapestArr);\r\n  }\r\n\r\n  calculateTimeDifferenceInMins(\r\n    railJourney: RailJourneyOption | RailSegment\r\n  ): string {\r\n    return this.helpers\r\n      .getTimeDifference(railJourney.arriveDateTime, railJourney.departDateTime)\r\n      .toString();\r\n  }\r\n\r\n  /**\r\n   * @description - determine if a ticket is an eTicket\r\n   * @param ticket - the ticket we want to to check\r\n   * @returns - boolean\r\n   */\r\n  ticketIsAnETicket(ticket: RailTicketOption): boolean {\r\n    let foundETicket = null;\r\n\r\n    foundETicket = ticket.ticketQueueList.find((queueListItem) => {\r\n      return queueListItem.type === 'eTicket';\r\n    });\r\n\r\n    return foundETicket ? true : null;\r\n  }\r\n\r\n  /**\r\n   * @description - clear all of our chosen tickets/other rail stuff, call this when kicking off a new search\r\n   */\r\n  clearChosenTickets(): void {\r\n    this._chosenInboundTicket = null;\r\n    this._chosenOutboundTicket = null;\r\n    this._chosenInboundJourney = null;\r\n    this._chosenOutboundJourney = null;\r\n    this._chosenTicketGroup = null;\r\n  }\r\n}\r\n"]}