incyclist-services 1.7.135 → 1.7.137

package/lib/cjs/i18n/countries/service.js

@@ -96,23 +96,7 @@ let Countries = (() => {
             return countries.map(c => this.getIsoFromCountry(c, locale));
         }
         async getIsoFromLatLng(point) {
-            const { lat, lng } = point;
-            const query = `[out:json][timeout:10];is_in(${lat},${lng})->.a;rel(pivot.a)['admin_level'='2']['boundary'='administrative'];out tags;`;
-            try {
-                const result = await this.getOverpassApi().query(query);
-                if (!result?.elements)
-                    return undefined;
-                const isos = result.elements
-                    .map(el => el.tags['ISO3166-1:alpha2'])
-                    .filter((iso) => !!iso)
-                    .map(iso => iso.toUpperCase());
-                if (isos.length < 2)
-                    return isos[0];
-                return isos.find(iso => this.getList().countries[iso] !== undefined);
-            }
-            catch {
-                return undefined;
-            }
+            return;
         }
         getOverpassApi() {
             return (0, services_1.useOverpassApi)();

package/lib/cjs/ride/display/service.js

@@ -443,10 +443,11 @@ let RideDisplayService = (() => {
         }
         async stopRide(props = {}) {
             try {
-                if (this.state !== 'Starting' && this.state !== 'Idle') {
-                    this.logEvent({ message: "activity stopped", activity: this.activity?.id, lastState: this.state });
-                }
                 const prevState = this.state;
+                const isRedundantCall = prevState === 'Finished' || prevState === 'Idle' || prevState === 'Closing';
+                if (!isRedundantCall && this.activity) {
+                    this.logEvent({ message: "activity stopped", activity: this.activity?.id, lastState: prevState });
+                }
                 this.state = prevState === 'Starting' ? 'Closing' : 'Finished';
                 this.observer?.stop({ immediately: props.noStateUpdates });
                 if (props.noStateUpdates)
@@ -456,7 +457,7 @@ let RideDisplayService = (() => {
                     (0, utils_1.waitNextTick)().then(() => { if (this.observer === observerToClear)
                         delete this.observer; });
                 }
-                if (prevState === 'Finished' || prevState === 'Idle' || prevState === 'Closing') {
+                if (isRedundantCall) {
                     this.state = 'Idle';
                     return;
                 }

package/lib/cjs/ride/route/GpxDisplayService.js

@@ -140,10 +140,10 @@ let GpxDisplayService = (() => {
             }
         }
         waitsForStreetView() {
-            return this.isMobile() && this.getRideSettingsDisplay().getRideView() === 'sv';
+            return this.getRideSettingsDisplay().getRideView() === 'sv';
         }
         waitsForSatelliteView() {
-            return this.isMobile() && this.getRideSettingsDisplay().getRideView() === 'sat';
+            return this.getRideSettingsDisplay().getRideView() === 'sat';
         }
         getSatelliteViewProps() {
             return {
@@ -217,8 +217,8 @@ let GpxDisplayService = (() => {
                 this.clearSatelliteViewStartTimeout();
             }
             else if (state === 'Error') {
-                this.logEvent({ message: 'sat view error', error: this.mapError });
                 this.mapError = error;
+                this.logEvent({ message: 'sat view error', error: this.mapError });
             }
             this.emit('state-update');
         }

package/lib/cjs/ride/route/RLVDisplayService.js

@@ -131,7 +131,7 @@ let RLVDisplayService = (() => {
                 }
                 await this.checkForAdditionalVideos(videoRoute);
                 const nextId = (0, routes_1.getNextVideoId)(videoRoute);
-                this.logEvent({ message: 'video added', id: videoRoute.description.id, title: videoRoute.description.title, segmentDistance: videoRoute.description.distance, next: nextId });
+                this.logEvent({ message: 'video added', id: videoRoute.description.id, title: videoRoute.description.title, segmentDistance: videoRoute.description.distance, next: nextId, src: video?.source });
             }
             catch (err) {
                 this.logError(err, 'addVideo');
@@ -524,7 +524,7 @@ let RLVDisplayService = (() => {
             video.source.getObserver().on('convert-error', (message) => this.onConvertError(message, video));
         }
         cleanupUrl(url) {
-            return (0, video_1.resolvePlaybackUrl)(url, this.isMobile());
+            return (0, video_1.resolvePlaybackUrl)(url);
         }
         isLoopEnabled() {
             return this.isLoop() && !this.startSettings?.loopOverwrite;

package/lib/cjs/routes/base/parsers/gpx.js

@@ -4,16 +4,27 @@ exports.GPXParser = void 0;
 const utils_1 = require("../../../utils");
 const math_1 = require("../../../utils/math");
 const valid_1 = require("../../../utils/valid");
+const xml_1 = require("../../../utils/xml");
 const route_1 = require("../utils/route");
-const xml_1 = require("./xml");
+const gpxFast_1 = require("./gpxFast");
+const xml_2 = require("./xml");
 const MIN_DISTANCE = 1;
-class GPXParser extends xml_1.XMLParser {
+class GPXParser extends xml_2.XMLParser {
     static SCHEME = 'gpx';
     props;
     constructor(props = {}) {
         super();
         this.props = props;
     }
+    async getData(file, data) {
+        if (data)
+            return data;
+        const resData = await this.readAndDecode(file);
+        const fast = (0, gpxFast_1.tryParseGpxRaw)(resData);
+        if (fast)
+            return new xml_1.XmlJSON(fast, 'gpx');
+        return await (0, xml_1.parseXml)(resData);
+    }
     getPrimaryExtension() {
         return 'gpx';
     }
@@ -125,7 +136,7 @@ class GPXParser extends xml_1.XMLParser {
                         original: gpxPt,
                         parsed: point
                     };
-                    this.logger.logEvent({ message: 'error', fn: 'loadPoints', reason: 'unvalid point', info });
+                    this.getLogger()?.logEvent({ message: 'error', fn: 'loadPoints', reason: 'unvalid point', info });
                     return;
                 }
                 if (this.props.addTime) {

package/lib/cjs/routes/base/parsers/gpxFast.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseGpxRaw = void 0;
+const decodeEntities = (s) => s.replaceAll('&lt;', '<').replaceAll('&gt;', '>').replaceAll('&quot;', '"').replaceAll('&apos;', "'").replaceAll('&amp;', '&');
+const isTagWhitespace = (c) => c === ' ' || c === '\t' || c === '\n' || c === '\r';
+const isAttrBoundary = (c) => c === '=' || c === '>' || c === '/' || isTagWhitespace(c);
+const skipBoundary = (s, i) => {
+    while (i < s.length && (s[i] === '<' || isAttrBoundary(s[i])))
+        i++;
+    return i;
+};
+const skipWhitespace = (s, i) => {
+    while (i < s.length && isTagWhitespace(s[i]))
+        i++;
+    return i;
+};
+const readToken = (s, i) => {
+    const start = i;
+    while (i < s.length && !isAttrBoundary(s[i]))
+        i++;
+    return { token: s.slice(start, i), next: i };
+};
+const readAttr = (s, i) => {
+    const { token: name, next: afterName } = readToken(s, i);
+    let j = skipWhitespace(s, afterName);
+    if (s[j] !== '=')
+        return { name, next: j };
+    j = skipWhitespace(s, j + 1);
+    const quote = s[j];
+    if (quote !== '"' && quote !== "'")
+        return { name, next: j };
+    const valueStart = j + 1;
+    const closeIdx = s.indexOf(quote, valueStart);
+    if (closeIdx === -1)
+        return { name, next: s.length };
+    return { name, value: s.slice(valueStart, closeIdx), next: closeIdx + 1 };
+};
+const parseAttrs = (tagText) => {
+    const attrs = {};
+    let i = 0;
+    while (i < tagText.length) {
+        i = skipBoundary(tagText, i);
+        if (i >= tagText.length)
+            break;
+        const { name, value, next } = readAttr(tagText, i);
+        if (name && value !== undefined)
+            attrs[name] = value;
+        i = next;
+    }
+    return attrs;
+};
+const CDATA_RE = /^<!\[CDATA\[([\s\S]*)\]\]>$/;
+const extractLeaf = (block, tag) => {
+    const openTag = `<${tag}`;
+    const start = block.indexOf(openTag);
+    if (start === -1)
+        return undefined;
+    const afterName = block[start + 1 + tag.length];
+    if (afterName !== undefined && !/[\s>/]/.test(afterName))
+        return undefined;
+    const tagEnd = block.indexOf('>', start);
+    if (tagEnd === -1)
+        return undefined;
+    if (block[tagEnd - 1] === '/')
+        return '';
+    const closeTag = `</${tag}>`;
+    const closeIdx = block.indexOf(closeTag, tagEnd);
+    if (closeIdx === -1)
+        return undefined;
+    const raw = block.slice(tagEnd + 1, closeIdx).trim();
+    const cdata = CDATA_RE.exec(raw);
+    return cdata ? cdata[1] : decodeEntities(raw);
+};
+const extractBlocks = (text, tag) => {
+    const blocks = [];
+    let idx = 0;
+    while (true) {
+        const start = text.indexOf(`<${tag}`, idx);
+        if (start === -1)
+            break;
+        const afterName = text[start + 1 + tag.length];
+        if (afterName !== undefined && !/[\s>/]/.test(afterName)) {
+            idx = start + 1;
+            continue;
+        }
+        const tagEnd = text.indexOf('>', start);
+        if (tagEnd === -1)
+            return undefined;
+        if (text[tagEnd - 1] === '/') {
+            blocks.push({ body: '' });
+            idx = tagEnd + 1;
+            continue;
+        }
+        const closeTag = `</${tag}>`;
+        const closeIdx = text.indexOf(closeTag, tagEnd);
+        if (closeIdx === -1)
+            return undefined;
+        blocks.push({ body: text.slice(tagEnd + 1, closeIdx) });
+        idx = closeIdx + closeTag.length;
+    }
+    return blocks;
+};
+const parseOneTrkpt = (segBody, start) => {
+    const tagEnd = segBody.indexOf('>', start);
+    if (tagEnd === -1)
+        return undefined;
+    const attrs = parseAttrs(segBody.slice(start, tagEnd + 1));
+    const point = { $: { lat: attrs.lat, lon: attrs.lon } };
+    if (segBody[tagEnd - 1] === '/')
+        return { point, nextIdx: tagEnd + 1 };
+    const closeIdx = segBody.indexOf('</trkpt>', tagEnd);
+    if (closeIdx === -1)
+        return undefined;
+    const body = segBody.slice(tagEnd + 1, closeIdx);
+    const ele = extractLeaf(body, 'ele');
+    if (ele !== undefined)
+        point.ele = [ele];
+    const time = extractLeaf(body, 'time');
+    if (time !== undefined)
+        point.time = [time];
+    return { point, nextIdx: closeIdx + '</trkpt>'.length };
+};
+const extractTrkpts = (segBody) => {
+    const points = [];
+    let idx = 0;
+    while (true) {
+        const start = segBody.indexOf('<trkpt', idx);
+        if (start === -1)
+            break;
+        const afterName = segBody[start + 6];
+        if (afterName !== undefined && !/[\s>/]/.test(afterName)) {
+            idx = start + 1;
+            continue;
+        }
+        const parsed = parseOneTrkpt(segBody, start);
+        if (!parsed)
+            return undefined;
+        points.push(parsed.point);
+        idx = parsed.nextIdx;
+    }
+    return points;
+};
+const buildTrk = (body) => {
+    const segStart = body.search(/<trkseg[\s>]/);
+    const header = segStart === -1 ? body : body.slice(0, segStart);
+    const segBlocks = extractBlocks(body, 'trkseg');
+    if (!segBlocks)
+        return undefined;
+    const trkseg = [];
+    for (const seg of segBlocks) {
+        const points = extractTrkpts(seg.body);
+        if (!points)
+            return undefined;
+        trkseg.push({ trkpt: points });
+    }
+    const trkObj = { trkseg };
+    const name = extractLeaf(header, 'name');
+    if (name !== undefined)
+        trkObj.name = [name];
+    const desc = extractLeaf(header, 'desc');
+    if (desc !== undefined)
+        trkObj.desc = [desc];
+    return trkObj;
+};
+const buildMetadata = (xmlText) => {
+    const metaMatch = /<metadata[\s>][\s\S]*?<\/metadata>/.exec(xmlText);
+    if (!metaMatch)
+        return undefined;
+    const openEnd = metaMatch[0].indexOf('>');
+    const closeStart = metaMatch[0].lastIndexOf('</metadata>');
+    const body = metaMatch[0].slice(openEnd + 1, closeStart).replace(/<author[\s>][\s\S]*?<\/author>/, '');
+    const name = extractLeaf(body, 'name');
+    return name !== undefined ? { name: [name] } : undefined;
+};
+const countPoints = (trk) => trk.reduce((sum, t) => sum + t.trkseg.reduce((s, seg) => s + seg.trkpt.length, 0), 0);
+const tryParseGpxRaw = (xmlText) => {
+    try {
+        if (!/<gpx[\s>]/.test(xmlText))
+            return undefined;
+        const trkBlocks = extractBlocks(xmlText, 'trk');
+        if (!trkBlocks || trkBlocks.length === 0)
+            return undefined;
+        const trk = [];
+        for (const { body } of trkBlocks) {
+            const trkObj = buildTrk(body);
+            if (!trkObj)
+                return undefined;
+            trk.push(trkObj);
+        }
+        const gpx = { trk };
+        const metadata = buildMetadata(xmlText);
+        if (metadata)
+            gpx.metadata = [metadata];
+        const literalCount = (xmlText.match(/<trkpt[\s>]/g) ?? []).length;
+        if (countPoints(trk) !== literalCount)
+            return undefined;
+        return { gpx };
+    }
+    catch {
+        return undefined;
+    }
+};
+exports.tryParseGpxRaw = tryParseGpxRaw;

package/lib/cjs/routes/base/parsers/incyclist.js

@@ -49,7 +49,8 @@ class IncyclistXMLParser extends xml_1.XMLParser {
             gpxFile.url = gpxFile.url.replace(xmlBase, fileName);
         }
         else {
-            gpxFile.filename = gpxFile.filename.replace(xmlBase, fileName);
+            const encodedFileName = fileInfo.delimiter === '%2F' ? encodeURIComponent(fileName) : fileName;
+            gpxFile.filename = `${fileInfo.dir}${fileInfo.delimiter}${encodedFileName}`;
         }
         try {
             let points;

package/lib/cjs/routes/base/parsers/utils.js

@@ -142,8 +142,8 @@ const safeEncode = (path) => {
 };
 exports.safeEncode = safeEncode;
 const handleFileUrlPath = (fileName) => {
-    const cleanPath = (0, exports.safeDecode)(fileName.replace(/^file:\/\/\/?/, ''));
-    return `file://${encodeURI(cleanPath)}`;
+    const cleanPath = (0, exports.safeDecode)(fileName.replace(/^file:\/\//, ''));
+    return (0, exports.buildFileUrl)(cleanPath);
 };
 const buildFileUrl = (normalizedPath) => {
     if (isAbsolutePath(normalizedPath)) {
@@ -231,26 +231,31 @@ const decodeUtf16Be = (data) => {
     return Buffer.from(swapped.toString('utf16le')).toString('utf-8');
 };
 const getUtf8Data = (res) => {
-    const buf = Buffer.isBuffer(res) ? res : Buffer.from(res, 'binary');
-    if (buf[0] === 0xFE && buf[1] === 0xFF) {
+    const prefix = Buffer.isBuffer(res) ? res.subarray(0, 4) : Buffer.from(res.slice(0, 4), 'binary');
+    if (prefix[0] === 0xFE && prefix[1] === 0xFF) {
+        const buf = Buffer.isBuffer(res) ? res : Buffer.from(res, 'binary');
         return decodeUtf16Be(buf.subarray(2));
     }
-    if (buf[0] === 0xFF && buf[1] === 0xFE) {
+    if (prefix[0] === 0xFF && prefix[1] === 0xFE) {
+        const buf = Buffer.isBuffer(res) ? res : Buffer.from(res, 'binary');
         return Buffer.from(buf.subarray(2).toString('utf16le')).toString('utf-8');
     }
-    if (buf[0] === 0xFD && buf[1] === 0xFD) {
-        if (buf[2] === 0x00 && buf[3] === 0x3C) {
+    if (prefix[0] === 0xFD && prefix[1] === 0xFD) {
+        const buf = Buffer.isBuffer(res) ? res : Buffer.from(res, 'binary');
+        if (prefix[2] === 0x00 && prefix[3] === 0x3C) {
             return decodeUtf16Be(buf.subarray(2));
         }
-        if (buf[2] === 0x3C && buf[3] === 0x00) {
+        if (prefix[2] === 0x3C && prefix[3] === 0x00) {
             return Buffer.from(buf.subarray(2).toString('utf16le')).toString('utf-8');
         }
     }
-    const str = typeof res === 'string' ? res : buf.toString('utf-8');
+    const str = typeof res === 'string' ? res : res.toString('utf-8');
     if (str.codePointAt(0) === 0xFEFF)
         return str.slice(1);
-    if (buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF)
+    if (prefix[0] === 0xEF && prefix[1] === 0xBB && prefix[2] === 0xBF) {
+        const buf = Buffer.isBuffer(res) ? res : Buffer.from(res, 'binary');
         return buf.subarray(3).toString('utf-8');
+    }
     return str;
 };
 exports.getUtf8Data = getUtf8Data;

package/lib/cjs/routes/base/parsers/xml.js

@@ -35,6 +35,10 @@ class XMLParser {
     async getData(file, data) {
         if (data)
             return data;
+        const resData = await this.readAndDecode(file);
+        return await (0, xml_1.parseXml)(resData);
+    }
+    async readAndDecode(file) {
         const onError = () => {
             throw new Error('Could not open file: ' + (0, utils_2.getFileName)(file));
         };
@@ -45,9 +49,7 @@ class XMLParser {
                 this.getLogger().logEvent({ message: '[Parser] getData error', error: res.error });
                 onError();
             }
-            const resData = (0, utils_1.getUtf8Data)(res.data);
-            const xml = await (0, xml_1.parseXml)(resData);
-            return xml;
+            return (0, utils_1.getUtf8Data)(res.data);
         }
         catch (err) {
             this.getLogger().logEvent({ message: '[Parser] getData error', error: err.message });
@@ -278,6 +280,14 @@ class XMLParser {
         let prevDistance = 0;
         route.elevation = 0;
         const points = [];
+        const altitudeByDistance = new Map();
+        if (Array.isArray(altitudes)) {
+            altitudes.forEach(a => {
+                const d = Number.parseInt(a.distance);
+                if (!altitudeByDistance.has(d))
+                    altitudeByDistance.set(d, a.height);
+            });
+        }
         positions.forEach((pos, i) => {
             if (i > 0) {
                 const prev = positions[i - 1];
@@ -285,7 +295,7 @@ class XMLParser {
                     return;
                 }
             }
-            const altitude = getAltitude(altitudes, positions, i, prevAltitude);
+            const altitude = getAltitude(altitudes, altitudeByDistance, positions, i, prevAltitude);
             const elevationGain = altitude - prevAltitude;
             const pi = createPoint(pos, altitude, prevDistance);
             pi.point.cnt = i;
@@ -342,7 +352,7 @@ function createPoint(pos, altitude, prevDistance) {
     }
     return { point, prevDistance };
 }
-function getAltitude(altitudes, positions, i, prevAltitude) {
+function getAltitude(altitudes, altitudeByDistance, positions, i, prevAltitude) {
     const pos = positions[i];
     let height = altitudes[i]?.height;
     if (altitudes && Array.isArray(altitudes)) {
@@ -350,8 +360,7 @@ function getAltitude(altitudes, positions, i, prevAltitude) {
             return height !== undefined ? Number(height) : prevAltitude;
         }
         else {
-            const altFound = altitudes.find(a => Number.parseInt(a.distance) === Number.parseInt(pos.distance));
-            height = altFound?.height;
+            height = altitudeByDistance.get(Number.parseInt(pos.distance));
             return height !== undefined ? Number(height) : prevAltitude;
         }
     }

package/lib/cjs/routes/library/service.js

@@ -371,6 +371,7 @@ let RouteLibraryScannerService = (() => {
                 const file = this.buildFileInfo(target.controlFileUri, target.format);
                 this.importProps.routes.push({
                     format: target.format,
+                    parseState: 'waiting',
                     importable: false,
                     label: file.base,
                     id: target.controlFileUri,
@@ -401,8 +402,12 @@ let RouteLibraryScannerService = (() => {
         async _parseTarget(target, service, observer) {
             let result;
             const file = this.buildFileInfo(target.controlFileUri, target.format);
+            const importProps = this.importProps.routes.find(r => r.id === target.controlFileUri) ?? {};
             try {
+                importProps.parseState = 'parsing';
+                observer.emit('updated', importProps);
                 result = await parsers_1.RouteParser.parse(file);
+                importProps.parseState = 'parsed';
                 const route = new route_1.Route(result.data, result.details);
                 const existing = this.importProps.routes.find(ri => ri.id === route.description.id);
                 if (existing) {
@@ -425,6 +430,7 @@ let RouteLibraryScannerService = (() => {
                 observer.emit('parse-result', parsed);
             }
             catch (err) {
+                importProps.parseState = 'parsed';
                 const parsed = {
                     alreadyImported: false,
                     route: result ? new route_1.Route(result.data, result.details) : undefined,
@@ -581,6 +587,9 @@ let RouteLibraryScannerService = (() => {
                 delimiter: uri?.startsWith('content://') ? '%2F' : '/'
             };
         }
+        getImportProps(parsed) {
+            return this.importProps.routes.find(r => r.id === parsed.controlFileUri);
+        }
         buildRouteDisplayItem(parsed, observer) {
             const { route, alreadyImported, parseError, format, controlFileUri } = parsed;
             const descr = route?.description ?? {};
@@ -591,11 +600,13 @@ let RouteLibraryScannerService = (() => {
             };
             const path = this.getBindings().path;
             const info = path.parse(controlFileUri);
+            const importProps = this.getImportProps(parsed);
             return {
                 id: route?.description?.id ?? info?.base,
                 distance,
                 label: route?.title ?? info?.base,
                 alreadyImported,
+                parseState: importProps?.parseState ?? 'waiting',
                 importable: parseError == null,
                 format,
                 errorReason: parseError,

package/lib/cjs/services/overpass/overpass.js

@@ -33,12 +33,8 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useOverpassApi = exports.OverpassApi = exports.OVERPASS_URL_DEFAULT = void 0;
-const promise_any_1 = __importDefault(require("promise.any"));
 const types_1 = require("../../base/types");
 const sleep_1 = require("../../utils/sleep");
 const base_1 = require("../../apps/base/api/base");
@@ -47,9 +43,10 @@ const decorators_1 = require("../../base/decorators");
 const api_1 = require("../../api");
 const settings_1 = require("../../settings");
 const OVERPASS_URL_PRIMARY = 'https://overpass-api.de/api/interpreter';
-const OVERPASS_URL_ALT1 = 'https://overpass.kumi.systems/api/interpreter';
-const OVERPASS_URL_ALT2 = 'https://overpass.openstreetmap.fr/api/interpreter';
+const OVERPASS_URL_ALT2 = 'https://lz4.overpass-api.de/api/interpreter';
+const OVERPASS_URL_ALT3 = 'https://maps.mail.ru/osm/tools/overpass/api/interpreter';
 exports.OVERPASS_URL_DEFAULT = OVERPASS_URL_PRIMARY;
+const DEFAULT_MIRRORS = [OVERPASS_URL_PRIMARY, OVERPASS_URL_ALT2, OVERPASS_URL_ALT3];
 let OverpassApi = (() => {
     let _classDecorators = [types_1.Singleton];
     let _classDescriptor;
@@ -77,7 +74,7 @@ let OverpassApi = (() => {
         logger;
         constructor(props) {
             super();
-            this.mirrors = [OVERPASS_URL_PRIMARY, OVERPASS_URL_ALT1, OVERPASS_URL_ALT2];
+            this.mirrors = DEFAULT_MIRRORS;
             this.url = props?.url ?? this.mirrors[0];
             this.logger = new gd_eventlog_1.EventLogger('Overpass');
             if (props?.url) {
@@ -128,25 +125,19 @@ let OverpassApi = (() => {
         async postViaFetchBinding(fetchBinding, url, data) {
             const headers = this.getOverpassHeaders();
             const body = typeof data === 'string' ? data : JSON.stringify(data);
-            try {
-                const res = await fetchBinding.fetch(url, {
-                    method: 'POST',
-                    headers,
-                    body,
-                    referrerPolicy: 'unsafe-url'
-                });
-                return {
-                    data: res.data,
-                    status: res.status,
-                    statusText: res.statusText,
-                    headers: res.headers,
-                    config: {}
-                };
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'fetch error', url, data, error: err.message });
-                throw err;
-            }
+            const res = await fetchBinding.fetch(url, {
+                method: 'POST',
+                headers,
+                body,
+                referrerPolicy: 'unsafe-url'
+            });
+            return {
+                data: res.data,
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers,
+                config: {}
+            };
         }
         async postViaNodeHttps(https, url, data) {
             return new Promise((resolve, reject) => {
@@ -245,10 +236,12 @@ let OverpassApi = (() => {
                 }));
             });
             if (timeout !== undefined && timeout !== null) {
-                promises.push((0, sleep_1.sleep)(timeout).then(() => 'timeout'));
+                promises.push((0, sleep_1.sleep)(timeout).then(() => {
+                    return 'timeout';
+                }));
             }
             try {
-                const res = await (0, promise_any_1.default)(promises);
+                const res = await Promise.any(promises);
                 if (res === 'timeout') {
                     return undefined;
                 }
@@ -289,7 +282,7 @@ let OverpassApi = (() => {
             throw lastError;
         }
         reset() {
-            this.mirrors = [OVERPASS_URL_PRIMARY, OVERPASS_URL_ALT1, OVERPASS_URL_ALT2];
+            this.mirrors = DEFAULT_MIRRORS;
             this.url = this.mirrors[0];
         }
         getAppVersion() {

package/lib/cjs/video/resolvePlaybackUrl.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePlaybackUrl = void 0;
-const resolvePlaybackUrl = (url, isMobile = false) => {
+const resolvePlaybackUrl = (url) => {
     if (!url)
         return undefined;
     let fileName = url;
@@ -10,8 +10,6 @@ const resolvePlaybackUrl = (url, isMobile = false) => {
         fileName = fileName.replace('incyclist:', 'file:');
     if (fileName.startsWith('video:') && !lc.endsWith('.avi'))
         return fileName.replace('video:', 'file:');
-    if (fileName.startsWith('file:') && !lc.endsWith('.avi') && !isMobile)
-        return fileName.replace('file:', 'video:');
     if (fileName.startsWith('video:') && lc.endsWith('.avi'))
         return fileName;
     if (fileName.startsWith('file:') || fileName.startsWith('http:') || fileName.startsWith('https:') || fileName.startsWith('/'))

package/lib/esm/i18n/countries/service.js

@@ -90,23 +90,7 @@ let Countries = (() => {
             return countries.map(c => this.getIsoFromCountry(c, locale));
         }
         async getIsoFromLatLng(point) {
-            const { lat, lng } = point;
-            const query = `[out:json][timeout:10];is_in(${lat},${lng})->.a;rel(pivot.a)['admin_level'='2']['boundary'='administrative'];out tags;`;
-            try {
-                const result = await this.getOverpassApi().query(query);
-                if (!result?.elements)
-                    return undefined;
-                const isos = result.elements
-                    .map(el => el.tags['ISO3166-1:alpha2'])
-                    .filter((iso) => !!iso)
-                    .map(iso => iso.toUpperCase());
-                if (isos.length < 2)
-                    return isos[0];
-                return isos.find(iso => this.getList().countries[iso] !== undefined);
-            }
-            catch {
-                return undefined;
-            }
+            return;
         }
         getOverpassApi() {
             return useOverpassApi();