incyclist-services 1.3.19 → 1.3.21

package/lib/maps/ways/utils.js

@@ -0,0 +1,619 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destinationPoint = exports.alongTrackDistanceTo = exports.initialBearingTo = exports.isWithinBoundary = exports.getBounds = exports.getVector = exports.getCrossingInfo = exports.getPointCrossingPath = exports.getCrossing = exports.isWithinRange = exports.getNearestPath = exports.distanceToPath = exports.isBetween = exports._getPointOnLine = exports.findAdditional = exports.getFirstBranch = exports.isOneWay = exports.isAllowed = exports.isNode = exports.isWay = exports.pointEquals = exports.boundaryToString = exports.generateQuery = exports.buildQuery = exports.generateID = exports.splitAtPoint = exports.removeDuplicates = exports.splitAtIndex = exports.isRoundabout = exports.getUntilFirstBranch = exports.splitAtPointInfo = exports.parseMapData = exports.updateTypeStats = exports.addWay = exports.addNode = void 0;
+const utils_1 = require("../../utils");
+const geo_1 = require("../../utils/geo");
+const math_1 = require("../../utils/math");
+const consts_1 = require("./consts");
+function addNode(node, nodesLookup, id, path) {
+    let point = nodesLookup[node];
+    if (point !== undefined)
+        path.push(point);
+    if (point.ways === undefined)
+        point.ways = [];
+    let found = point.ways.find(e => (e.toString() === id.toString()));
+    if (found === undefined)
+        nodesLookup[node].ways.push(id.toString());
+}
+exports.addNode = addNode;
+function addWay(w, ways, waysLookup) {
+    if (waysLookup[w.id] !== undefined)
+        ways = ways.filter(e => e.id !== w.id);
+    ways.push(w);
+    waysLookup[w.id.toString()] = w;
+}
+exports.addWay = addWay;
+function updateTypeStats(types, type) {
+    let t = (type === undefined ? '-' : type);
+    if (types[t] !== undefined)
+        types[t]++;
+    else
+        types[t] = 1;
+}
+exports.updateTypeStats = updateTypeStats;
+function parseMapData(str, filter) {
+    if (str === undefined)
+        return;
+    let data;
+    if (typeof (str) === 'string') {
+        try {
+            data = JSON.parse(str);
+        }
+        catch (error) {
+            return;
+        }
+    }
+    else {
+        data = str;
+    }
+    if (data.elements === undefined)
+        return;
+    let nodesLookup = {};
+    let waysLookup = {};
+    let ways = [];
+    let types = {};
+    let idx = 0;
+    let id;
+    data.elements.forEach(element => {
+        if (element.type === 'node') {
+            id = (element.id !== undefined && typeof element.id === 'number') ? id = element.id.toString() : '_INT_' + idx;
+            nodesLookup[element.id.toString()] = { id, lat: element.lat, lng: element.lon, tags: element.tags };
+            idx++;
+        }
+    });
+    idx = 0;
+    data.elements.forEach(element => {
+        var _a, _b, _c;
+        let path = [];
+        if (element.type === 'way') {
+            const way = element;
+            id = (element.id !== undefined && typeof element.id === 'number') ? id = element.id.toString() : '_INT_' + idx;
+            const name = (_a = element.tags) === null || _a === void 0 ? void 0 : _a.name;
+            const type = (_b = element.tags) === null || _b === void 0 ? void 0 : _b.highway;
+            if (type !== undefined && (filter === undefined || filter.find(e => e === type) === undefined)) {
+                (_c = way.nodes) === null || _c === void 0 ? void 0 : _c.forEach(node => {
+                    addNode(node, nodesLookup, id, path);
+                });
+                updateTypeStats(types, type);
+                addWay({ id: id.toString(), path, type, name, tags: element.tags, bounds: way.bounds }, ways, waysLookup);
+                idx++;
+            }
+        }
+    });
+    return { ways, nodesLookup, waysLookup, typeStats: types };
+}
+exports.parseMapData = parseMapData;
+function splitAtPointInfo(way, pointInfo) {
+    if (!way)
+        return;
+    let path = way.path;
+    let result = [[], []];
+    let foundBranch2 = false;
+    path.forEach((node, idx) => {
+        if (idx <= pointInfo.idx)
+            result[0].push(node);
+        if (idx === pointInfo.idx) {
+            result[1].push(node);
+        }
+        if (!foundBranch2 && idx > pointInfo.idx && node.ways.length === 1)
+            result[1].push(node);
+        if (!foundBranch2 && idx > pointInfo.idx && node.ways.length > 1) {
+            if (findAdditional(pointInfo.branches, node.ways, way.id, (id1, id2) => (id1 === id2)) !== undefined)
+                foundBranch2 = true;
+            result[1].push(node);
+        }
+    });
+    return result;
+}
+exports.splitAtPointInfo = splitAtPointInfo;
+function getUntilFirstBranch(w, props) {
+    if (!w)
+        return;
+    const reverse = (props !== undefined) ? props.reverse : false;
+    const ignore = (props !== undefined) ? props.ignore : undefined;
+    let branch;
+    let path = w.path;
+    if (reverse) {
+        w.path = [...path];
+        w.path.reverse();
+        path = w.path;
+    }
+    let piBranch = getFirstBranch(w, ignore);
+    if (piBranch !== undefined) {
+        branch = { id: w.id, path: [] };
+        path.forEach((p, idx) => {
+            if (idx <= piBranch.idx)
+                branch.path.push(p);
+        });
+    }
+    else {
+        branch = { id: w.id, path: w.path };
+    }
+    return branch;
+}
+exports.getUntilFirstBranch = getUntilFirstBranch;
+function isRoundabout(w, strictCheck = false) {
+    if (!w)
+        return;
+    let roundabout = (w.tags !== undefined && (w.tags.roundabout === true || w.tags.junction === 'roundabout'));
+    if (roundabout)
+        return true;
+    if (strictCheck)
+        return false;
+    if (w.path === undefined || w.path.length < 2)
+        return false;
+    roundabout = (w.path[0].id === w.path[w.path.length - 1].id);
+    return roundabout;
+}
+exports.isRoundabout = isRoundabout;
+function splitAtIndex(way, idxSplit) {
+    let path = way.path;
+    let result = [[], []];
+    path.forEach((p, idx) => {
+        if (idx <= idxSplit)
+            result[0].push(p);
+        if (idx >= idxSplit)
+            result[1].push(p);
+    });
+    return result;
+}
+exports.splitAtIndex = splitAtIndex;
+function removeDuplicates(options) {
+    const endPoints = [];
+    const unique = [];
+    const uniqueUsed = [];
+    options.forEach((o) => { endPoints.push(o.path[o.path.length - 1].id); });
+    endPoints.forEach((id) => {
+        if (unique.indexOf(id) < 0) {
+            unique.push(id);
+            uniqueUsed.push(false);
+        }
+    });
+    return options.filter((o) => {
+        const id = o.path[o.path.length - 1].id;
+        const idx = unique.indexOf(id);
+        if (idx >= 0 && !uniqueUsed[idx]) {
+            uniqueUsed[idx] = true;
+            return true;
+        }
+        return false;
+    });
+}
+exports.removeDuplicates = removeDuplicates;
+function splitAtPoint(way, point) {
+    let path = way.path;
+    let result = [{ id: way.id, path: [], onewayReverse: false }, { id: way.id, path: [], onewayReverse: false }];
+    let found = false;
+    let roundabout = isRoundabout(way);
+    if (!roundabout) {
+        path.forEach((p, idx) => {
+            if (!found)
+                result[0].path.push(p);
+            if (!found)
+                found = pointEquals(p, point);
+            if (found)
+                result[1].path.push(p);
+        });
+        result[0].path.reverse();
+        if (isOneWay(way))
+            result[0].onewayReverse = true;
+    }
+    else {
+        let idx = undefined;
+        path.forEach((p, i) => {
+            if (!found) {
+                found = pointEquals(p, point);
+                if (found)
+                    idx = i;
+            }
+        });
+        if (idx !== undefined) {
+            let i;
+            for (i = 0; i < path.length; i++) {
+                let len = path.length;
+                let p = path[(idx + i) % len];
+                let q = path[(idx - i + len) % len];
+                if (result[0].path.length === 0 ||
+                    (p.id !== result[0].path[result[0].path.length - 1].id && p.id !== result[0].path[0].id))
+                    result[0].path.push(p);
+                if (result[1].path.length === 0 ||
+                    (q.id !== result[1].path[result[1].path.length - 1].id && q.id !== result[1].path[0].id))
+                    result[1].path.push(q);
+            }
+            if (isOneWay(way)) {
+                result[1].onewayReverse = true;
+            }
+        }
+        else {
+            return ([]);
+        }
+    }
+    return result;
+}
+exports.splitAtPoint = splitAtPoint;
+function generateID(ways) {
+    if (ways === undefined || ways.length === 0)
+        return;
+    if (ways.length < 2)
+        return ways[0];
+    let w = [...ways];
+    let widStr = 'R:' + w.sort().join(',');
+    return widStr;
+}
+exports.generateID = generateID;
+;
+function buildQuery(template, boundary) {
+    if (template === undefined)
+        return;
+    return template.replace('__boundary__', boundaryToString(boundary));
+}
+exports.buildQuery = buildQuery;
+function generateQuery(location, radius) {
+    const boundary = getBounds(location.lat, location.lng, radius);
+    const template = consts_1.GET_WAYS_IN_AREA;
+    return buildQuery(template, boundary);
+}
+exports.generateQuery = generateQuery;
+function boundaryToString(boundary) {
+    if (boundary === undefined)
+        return 'undefined';
+    let ne = boundary.northeast;
+    let sw = boundary.southwest;
+    if (ne !== undefined && (ne.lat === undefined || ne.lng === undefined))
+        return 'error: northeast incorrect';
+    if (sw !== undefined && (sw.lat === undefined || sw.lng === undefined))
+        return 'error: southwest incorrect';
+    if (ne === undefined)
+        ne = sw;
+    if (sw === undefined)
+        sw = ne;
+    if (sw === undefined)
+        return 'undefined';
+    let str = sw.lat + ',' + sw.lng + ',' + ne.lat + ',' + ne.lng;
+    return str;
+}
+exports.boundaryToString = boundaryToString;
+function pointEquals(p1, p2) {
+    if (p1 === undefined || p2 === undefined)
+        return false;
+    return (p1.id === p2.id || (p1.lat !== undefined && p1.lng !== undefined && p1.lat === p2.lat && p1.lng === p2.lng));
+}
+exports.pointEquals = pointEquals;
+function isWay(p) {
+    if (p === undefined || p === null || p.id === undefined || p.path === undefined || p.tags === undefined)
+        return false;
+    return true;
+}
+exports.isWay = isWay;
+function isNode(p) {
+    if (p === undefined || p === null || p.id === undefined || p.lat === undefined || p.lng === undefined || p.ways === undefined)
+        return false;
+    return true;
+}
+exports.isNode = isNode;
+function isAllowed(way, from, to) {
+    if (isNode(from) && isWay(way)) {
+        const fromIdx = way.path.findIndex(p => p.id === from.id);
+        if (fromIdx !== -1 && !isOneWay(way))
+            return true;
+        let p0 = way.path[0];
+        let pN = way.path[way.path.length - 1];
+        if (from.id === p0.id)
+            return true;
+        if (from.id !== p0.id && from.id === pN.id)
+            return !isOneWay(way);
+        if (isNode(to) && to.id === pN.id)
+            return true;
+        if (isNode(from) && isNode(to)) {
+            const toId = way.path.findIndex(p => p.id === to.id);
+            if (fromIdx === -1 || toId === -1)
+                return;
+            return !isOneWay(way) || fromIdx < toId;
+        }
+    }
+    return undefined;
+}
+exports.isAllowed = isAllowed;
+function isOneWay(way) {
+    if (!way || !way.tags || !way.tags.oneway)
+        return false;
+    let ow = way.tags.oneway;
+    return (ow.toString() === 'true' || ow === 'yes');
+}
+exports.isOneWay = isOneWay;
+function getFirstBranch(way, ignore) {
+    if (way === undefined || way.path === undefined)
+        return;
+    let pFound = undefined;
+    way.path.forEach((node, idx) => {
+        if (idx === 0)
+            return;
+        let ways = [];
+        node.ways.forEach((w) => {
+            if (ignore === undefined || w !== ignore)
+                ways.push(w);
+        });
+        if (!pFound && node.ways !== undefined && ways.length > 1) {
+            let branches = [];
+            ways.forEach(pw => {
+                if (pw !== way.id)
+                    branches.push(pw);
+            });
+            pFound = { point: node, idx, branches };
+        }
+    });
+    return pFound;
+}
+exports.getFirstBranch = getFirstBranch;
+function findAdditional(a1, a2, id3, fn) {
+    let res = [];
+    a1.forEach(e1 => {
+        a2.forEach(e2 => {
+            if (!fn(e1, e2) && !fn(e1, id3) && !fn(e2, id3))
+                res.push(e2);
+        });
+    });
+    if (res.length === 0)
+        return undefined;
+    return res;
+}
+exports.findAdditional = findAdditional;
+function _getPointOnLine(point, p1, p2) {
+    let bL = initialBearingTo(p1, p2);
+    let bP = bL + 90;
+    let p3 = destinationPoint(point, 100, bP);
+    return getCrossing(p1, p2, point, p3, false);
+}
+exports._getPointOnLine = _getPointOnLine;
+function isBetween(point, p1, p2) {
+    if (point === undefined || p1 === undefined || p2 === undefined ||
+        point.lat === undefined || point.lng === undefined ||
+        p1.lat === undefined || p1.lng === undefined ||
+        p2.lat === undefined || p2.lng === undefined)
+        return undefined;
+    let d = utils_1.geo.distanceBetween(p1, point);
+    let bDest = initialBearingTo(p1, p2);
+    let bPoint = initialBearingTo(p1, point);
+    let angle = bPoint - bDest;
+    if ((0, math_1.abs)(angle) > 30)
+        return { between: false, offset: d };
+    let dP2 = utils_1.geo.distanceBetween(p1, p2);
+    let offset = (0, math_1.abs)(d * (0, math_1.sin)(angle));
+    if (offset < consts_1.MAX_DISTANCE_FROM_PATH && dP2 > d) {
+        return { between: true, offset };
+    }
+    return { between: false, offset: (dP2 - d) };
+}
+exports.isBetween = isBetween;
+function distanceToPath(point, way) {
+    if (point === undefined || point.lat === undefined || point.lng === undefined
+        || way === undefined || way.path === undefined || way.path.length === 0)
+        return undefined;
+    let minDistance;
+    let minIdx = -1;
+    let prev;
+    let foundExact = false;
+    way.path.forEach((element, idx) => {
+        if (element.lat === point.lat && element.lng === point.lng) {
+            minDistance = 0;
+            foundExact = true;
+            return;
+        }
+        if (foundExact)
+            return;
+        if (prev !== undefined) {
+            let res = isBetween(point, prev, element);
+            if (res && res.between) {
+                minDistance = res.offset;
+                foundExact = true;
+                return;
+            }
+        }
+        let distance = utils_1.geo.distanceBetween(element, point);
+        if (minDistance === undefined || distance < minDistance) {
+            minDistance = distance;
+            minIdx = idx;
+        }
+        prev = element;
+    });
+    if (foundExact)
+        return minDistance;
+    if (minIdx > 0) {
+        const alpha = initialBearingTo(way.path[minIdx - 1], way.path[minIdx]);
+        const alpha2 = initialBearingTo(way.path[minIdx - 1], point);
+        let beta = alpha2 - alpha;
+        if (beta > 270)
+            beta -= 360;
+        if ((beta > -90 && beta < 90)) {
+            const dist = (0, math_1.sin)((0, math_1.abs)(beta)) * utils_1.geo.distanceBetween(way.path[minIdx - 1], point);
+            const distPath = (0, math_1.cos)((0, math_1.abs)(beta)) * utils_1.geo.distanceBetween(way.path[minIdx - 1], point);
+            if (dist < minDistance && distPath > 0 && distPath < utils_1.geo.distanceBetween(way.path[minIdx - 1], way.path[minIdx]))
+                minDistance = dist;
+        }
+    }
+    if (minIdx < way.path.length - 2) {
+        const alpha = initialBearingTo(way.path[minIdx], way.path[minIdx + 1]);
+        let beta = initialBearingTo(way.path[minIdx], point) - alpha;
+        if (beta > 270)
+            beta -= 360;
+        if ((beta > -90 && beta < 90)) {
+            const dist = (0, math_1.sin)((0, math_1.abs)(beta)) * utils_1.geo.distanceBetween(way.path[minIdx], point);
+            const distPath = (0, math_1.cos)((0, math_1.abs)(beta)) * utils_1.geo.distanceBetween(way.path[minIdx], point);
+            if (dist < minDistance && distPath > 0 && distPath < utils_1.geo.distanceBetween(way.path[minIdx], way.path[minIdx + 1]))
+                minDistance = dist;
+        }
+    }
+    return minDistance;
+}
+exports.distanceToPath = distanceToPath;
+function getNearestPath(point, ways) {
+    if (ways === undefined || point === undefined)
+        return;
+    let w;
+    let min = { path: undefined, distance: undefined, way: undefined };
+    for (w of ways) {
+        let distance = distanceToPath(point, w);
+        if (distance !== undefined && (min.distance === undefined || distance < min.distance)) {
+            min.distance = distance;
+            min.path = w.path;
+            min.way = w;
+        }
+    }
+    return min;
+}
+exports.getNearestPath = getNearestPath;
+function isWithinRange(distance) {
+    return (0, math_1.abs)(distance) < consts_1.MAX_DISTANCE_FROM_PATH;
+}
+exports.isWithinRange = isWithinRange;
+function getCrossing(A, B, C, D, exact = true) {
+    let AB = getVector(A, B);
+    let CD = getVector(C, D);
+    let AC = getVector(A, C);
+    const ciA = Object.assign(Object.assign({}, A), { distance: 0 });
+    const ciB = Object.assign(Object.assign({}, B), { distance: utils_1.geo.distanceBetween(A, B) });
+    if (isWithinRange(utils_1.geo.distanceBetween(A, C)))
+        return ciA;
+    if (isWithinRange(utils_1.geo.distanceBetween(A, D)))
+        return ciA;
+    if (isWithinRange(utils_1.geo.distanceBetween(B, C)))
+        return ciB;
+    if (isWithinRange(utils_1.geo.distanceBetween(B, D)))
+        return ciB;
+    const V = (0, geo_1.crossing)(AB, CD, AC);
+    if (V === undefined)
+        return undefined;
+    const p1Len = AB.len();
+    const distance = V.len();
+    if (AB.isSameDirection(V) && (distance < p1Len || isWithinRange(p1Len - distance))) {
+        let X = utils_1.geo.getPointBetween(A, B, distance);
+        let CX = getVector(C, X);
+        if (!exact || (CX.len() < CD.len() || isWithinRange(CD.len() - CX.len()))) {
+            return Object.assign(Object.assign({}, X), { distance });
+        }
+    }
+    return undefined;
+}
+exports.getCrossing = getCrossing;
+function getPointCrossingPath(point, path, closest = false) {
+    let pPrev = undefined;
+    let X = undefined;
+    let pClosest = undefined;
+    if (path === undefined)
+        return undefined;
+    path.forEach((p, i) => {
+        let pDist = (0, math_1.abs)(utils_1.geo.distanceBetween(p, point));
+        if (pClosest === undefined || pClosest.distance > pDist) {
+            pClosest = { distance: pDist, point: p, idx: i };
+        }
+        if (pPrev !== undefined) {
+            let pX = _getPointOnLine(point, pPrev, p);
+            if (pX !== undefined) {
+                let dist = (0, math_1.abs)(utils_1.geo.distanceBetween(pX, point));
+                if (X === undefined || (X.distance > dist)) {
+                    X = { point: pX, distance: dist, idx: i };
+                }
+            }
+        }
+        pPrev = p;
+    });
+    if (X !== undefined) {
+        return X;
+    }
+    else {
+        if (closest)
+            return pClosest;
+    }
+}
+exports.getPointCrossingPath = getPointCrossingPath;
+function getCrossingInfo(way1, way2) {
+    if (way1 === undefined || way1.path === undefined || way2 === undefined || way2.path === undefined)
+        return;
+    let crossing = undefined;
+    way1.path.forEach((p1, i) => {
+        way2.path.forEach((p2, j) => {
+            if (crossing === undefined && p1.id === p2.id) {
+                crossing = { point: p1, idx1: i, idx2: j };
+            }
+        });
+    });
+    return crossing;
+}
+exports.getCrossingInfo = getCrossingInfo;
+function getVector(p1, p2) {
+    if (p1 === undefined)
+        throw new Error("missing mandatory argument: p1");
+    if (p2 === undefined)
+        throw new Error("missing mandatory argument: p2");
+    let distance = utils_1.geo.distanceBetween(p1, p2);
+    if (distance === 0) {
+        return new utils_1.Vector([0, 0]);
+    }
+    let bearing = initialBearingTo(p1, p2);
+    return new utils_1.Vector({ path: { bearing, distance } });
+}
+exports.getVector = getVector;
+function getBounds(lat, lng, offset) {
+    const pi = Math.PI;
+    const m = (1 / ((2 * pi / 360) * consts_1.RADIUS_EARTH)) / 1000;
+    let boundary = {
+        northeast: { lat: undefined, lng: undefined },
+        southwest: { lat: undefined, lng: undefined }
+    };
+    boundary.northeast.lat = lat + offset * m;
+    boundary.northeast.lng = lng + (offset * m) / Math.cos(lat * pi / 180);
+    boundary.southwest.lat = lat - offset * m;
+    boundary.southwest.lng = lng - (offset * m) / Math.cos(lat * pi / 180);
+    return boundary;
+}
+exports.getBounds = getBounds;
+function isWithinBoundary(location, boundary) {
+    if (location === undefined || location.lat === undefined || location.lng === undefined)
+        return false;
+    const lat = location.lat;
+    const lng = location.lng;
+    const sw = boundary.southwest;
+    const ne = boundary.northeast;
+    return (lat >= sw.lat && lat <= ne.lat && lng >= sw.lng && lng <= ne.lng);
+}
+exports.isWithinBoundary = isWithinBoundary;
+function initialBearingTo(p1, p2) {
+    if (p1 === undefined || p2 === undefined || (p1.lat === p2.lat && p1.lng === p2.lng))
+        return;
+    const φ1 = (0, math_1.rad)(p1.lat);
+    const φ2 = (0, math_1.rad)(p2.lat);
+    const Δλ = (0, math_1.rad)(p2.lng - p1.lng);
+    const x = Math.cos(φ1) * Math.sin(φ2) - Math.sin(φ1) * Math.cos(φ2) * Math.cos(Δλ);
+    const y = Math.sin(Δλ) * Math.cos(φ2);
+    const θ = Math.atan2(y, x);
+    const bearing = (0, math_1.degrees)(θ);
+    return bearing;
+}
+exports.initialBearingTo = initialBearingTo;
+function alongTrackDistanceTo(point, pathStart, pathEnd, radius = consts_1.RADIUS_EARTH * 1000) {
+    if (point === undefined || pathStart === undefined || pathEnd === undefined)
+        return;
+    const R = radius;
+    const δ13 = utils_1.geo.calculateDistance(pathStart.lat, pathStart.lng, point.lat, point.lng, R) / R;
+    const θ13 = (0, math_1.rad)(initialBearingTo(pathStart, point));
+    const θ12 = (0, math_1.rad)(initialBearingTo(pathStart, pathEnd));
+    const δxt = Math.asin(Math.sin(δ13) * Math.sin(θ13 - θ12));
+    const δat = Math.acos(Math.cos(δ13) / Math.abs(Math.cos(δxt)));
+    let d = δat * Math.sign(Math.cos(θ12 - θ13)) * R;
+    return d;
+}
+exports.alongTrackDistanceTo = alongTrackDistanceTo;
+function destinationPoint(start, distance, bearing, radius = consts_1.RADIUS_EARTH * 1000) {
+    const δ = distance / radius;
+    const θ = (0, math_1.rad)(bearing);
+    const φ1 = (0, math_1.rad)(start.lat), λ1 = (0, math_1.rad)(start.lng);
+    const sinφ2 = Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ);
+    const φ2 = Math.asin(sinφ2);
+    const y = Math.sin(θ) * Math.sin(δ) * Math.cos(φ1);
+    const x = Math.cos(δ) - Math.sin(φ1) * sinφ2;
+    const λ2 = λ1 + Math.atan2(y, x);
+    const lat = (0, math_1.degrees)(φ2);
+    const lng = (0, math_1.degrees)(λ2);
+    return { lat, lng };
+}
+exports.destinationPoint = destinationPoint;

package/lib/routes/base/parsers/incyclist.d.ts

@@ -1,7 +1,10 @@
+import { JSONObject } from '../../../utils';
+import { RouteApiDetail } from '../api/types';
 import { XMLParser, XmlParserContext } from './xml';
 export declare class IncyclistXMLParser extends XMLParser {
     static SCHEME: string;
     protected loadDescription(context: XmlParserContext): Promise<void>;
     protected loadPoints(context: XmlParserContext): Promise<void>;
+    protected processCuts(data: JSONObject, route: RouteApiDetail): void;
     protected parseVideo(context: XmlParserContext): Promise<void>;
 }