@nshiab/simple-data-analysis-core 2.0.2 → 2.0.4

package/script/methods/loadOpenStreetMap.js

@@ -0,0 +1,375 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadOpenStreetMap;
+exports.generateOverpassQuery = generateOverpassQuery;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const SDAError_js_1 = __importDefault(require("../class/SDAError.js"));
+const loadOsmFile_js_1 = __importDefault(require("../helpers/loadOsmFile.js"));
+const osmCache_js_1 = require("../helpers/osmCache.js");
+const osmFiles_js_1 = require("../helpers/osmFiles.js");
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const prettyDuration_js_1 = __importDefault(require("../helpers/prettyDuration.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const DEFAULT_OVERPASS_ENDPOINT = "https://overpass-api.de/api/interpreter";
+const DEFAULT_REMOTE_FILE_TIMEOUT = 30 * 60;
+const QUERY_GENERATOR_VERSION = "overpass-ql-v1";
+function loadOpenStreetMap(table, source, options = {}) {
+    if (typeof source === "string") {
+        queueOpenStreetMapFileLoad(table, source, options);
+        return;
+    }
+    queueOverpassLoad(table, source, options);
+}
+function queueOpenStreetMapFileLoad(table, file, options) {
+    const suffix = (0, osmFiles_js_1.getOsmFileSuffix)(file);
+    if (suffix === null) {
+        throw new Error("loadOpenStreetMap() file paths and URLs must end with .osm or .osm.pbf.");
+    }
+    options = structuredClone(options);
+    assertOptions(options, false);
+    let remoteUrl;
+    if ((0, osmFiles_js_1.isRemoteOsmUrl)(file)) {
+        remoteUrl = (0, osmFiles_js_1.normalizeRemoteOsmUrl)(file);
+    }
+    else {
+        try {
+            const url = new URL(file);
+            if (url.protocol !== "http:" && url.protocol !== "https:") {
+                throw new Error("loadOpenStreetMap() URL sources must use HTTP or HTTPS.");
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("must use HTTP")) {
+                throw error;
+            }
+        }
+        if (options.retries !== undefined || options.retryDelay !== undefined) {
+            throw new Error("loadOpenStreetMap() options.retries and options.retryDelay are network-only and cannot be used with a local path.");
+        }
+    }
+    const parameters = { file, options };
+    (0, queueOp_js_1.default)(table, {
+        kind: "barrier",
+        method: "loadOpenStreetMap()",
+        parameters,
+        execute: () => executeOpenStreetMapFileLoad(table, remoteUrl ?? file, suffix, options, parameters),
+    });
+}
+async function executeOpenStreetMapFileLoad(table, file, suffix, options, parameters) {
+    const started = Date.now();
+    const verbose = options.verbose === true || table.sdb.cacheVerbose;
+    const remote = (0, osmFiles_js_1.isRemoteOsmUrl)(file);
+    const displayedSource = remote ? (0, osmFiles_js_1.sanitizeOsmUrl)(file) : (0, node_path_1.resolve)(file);
+    verbose && console.log(`loadOpenStreetMap(): loading ${displayedSource}`);
+    try {
+        if (remote) {
+            const cacheId = (0, osmCache_js_1.createOsmCacheId)({ kind: "remote", url: file });
+            await (0, osmCache_js_1.useProcessedOsmCache)(table, {
+                id: cacheId,
+                enabled: options.cache ?? true,
+                ttl: options.ttl,
+                verbose,
+                parameters,
+                compute: async () => {
+                    const temporaryFile = await (0, osmFiles_js_1.downloadOsmToTemporaryFile)(file, {
+                        suffix,
+                        prefix: cacheId,
+                        request: { headers: { "accept-encoding": "gzip" } },
+                        retries: options.retries,
+                        retryDelay: options.retryDelay,
+                        timeout: DEFAULT_REMOTE_FILE_TIMEOUT,
+                        verbose,
+                    });
+                    try {
+                        await processOsmFile(table, temporaryFile, parameters, verbose);
+                    }
+                    finally {
+                        (0, node_fs_1.rmSync)(temporaryFile, { force: true });
+                        verbose && console.log("Removed the temporary raw OSM download.");
+                    }
+                },
+            });
+        }
+        else {
+            verbose &&
+                console.log("Resolving and fingerprinting the local OSM file...");
+            const fingerprintStarted = Date.now();
+            const resolvedPath = (0, node_fs_1.realpathSync)((0, node_path_1.resolve)(file));
+            const stat = (0, node_fs_1.statSync)(resolvedPath, { bigint: true });
+            if (!stat.isFile()) {
+                throw new Error(`The OpenStreetMap source is not a file: ${resolvedPath}`);
+            }
+            verbose && console.log(`Resolved ${(0, osmFiles_js_1.formatBytes)(Number(stat.size))} and fingerprinted it in ${(0, prettyDuration_js_1.default)(fingerprintStarted)}.`);
+            const cacheId = (0, osmCache_js_1.createOsmCacheId)({
+                kind: "local",
+                path: resolvedPath,
+                size: stat.size.toString(),
+                mtimeNs: stat.mtimeNs.toString(),
+            });
+            await (0, osmCache_js_1.useProcessedOsmCache)(table, {
+                id: cacheId,
+                enabled: options.cache ?? true,
+                ttl: options.ttl,
+                verbose,
+                parameters,
+                compute: () => processOsmFile(table, resolvedPath, parameters, verbose),
+            });
+        }
+        verbose && console.log(`loadOpenStreetMap(): completed in ${(0, prettyDuration_js_1.default)(started)}.`);
+    }
+    catch (error) {
+        if (error instanceof SDAError_js_1.default)
+            throw error;
+        throw new SDAError_js_1.default({
+            method: "loadOpenStreetMap()",
+            parameters,
+            query: "",
+            cause: error,
+        });
+    }
+}
+function queueOverpassLoad(table, bbox, options) {
+    bbox = normalizeBoundingBox(bbox);
+    options = structuredClone(options);
+    assertOptions(options, true);
+    const endpoint = normalizeEndpoint(options.endpoint ?? DEFAULT_OVERPASS_ENDPOINT);
+    const filters = normalizeFilters(options.filters);
+    const query = generateOverpassQuery(bbox, filters, options.timeout);
+    const parameters = { bbox, options };
+    (0, queueOp_js_1.default)(table, {
+        kind: "barrier",
+        method: "loadOpenStreetMap()",
+        parameters,
+        execute: () => executeOverpassLoad(table, options, endpoint, query, parameters),
+    });
+}
+async function executeOverpassLoad(table, options, endpoint, query, parameters) {
+    const started = Date.now();
+    const verbose = options.verbose === true || table.sdb.cacheVerbose;
+    verbose && console.log(`loadOpenStreetMap(): querying ${(0, osmFiles_js_1.sanitizeOsmUrl)(endpoint)}`);
+    try {
+        const cacheId = (0, osmCache_js_1.createOsmCacheId)({
+            kind: "overpass",
+            endpoint,
+            query,
+            queryGeneratorVersion: QUERY_GENERATOR_VERSION,
+        });
+        await (0, osmCache_js_1.useProcessedOsmCache)(table, {
+            id: cacheId,
+            enabled: options.cache ?? true,
+            ttl: options.ttl,
+            verbose,
+            parameters,
+            compute: async () => {
+                const body = new URLSearchParams({ data: query });
+                const temporaryFile = await (0, osmFiles_js_1.downloadOsmToTemporaryFile)(endpoint, {
+                    suffix: ".osm",
+                    prefix: cacheId,
+                    request: {
+                        method: "POST",
+                        headers: {
+                            "accept-encoding": "gzip",
+                            "content-type": "application/x-www-form-urlencoded;charset=UTF-8",
+                            "user-agent": "simple-data-analysis-core (https://github.com/nshiab/simple-data-analysis-core)",
+                        },
+                        body,
+                    },
+                    retries: options.retries,
+                    retryDelay: options.retryDelay,
+                    timeout: options.timeout,
+                    overpass: true,
+                    verbose,
+                });
+                try {
+                    try {
+                        await assertSuccessfulOverpassResponse(temporaryFile);
+                    }
+                    catch (error) {
+                        const reason = error instanceof Error
+                            ? error.message
+                            : String(error);
+                        throw new Error(`${reason}\nNot retrying because the Overpass response was well-formed and reported a query error.\nNo invalid cached data was returned.`, { cause: error });
+                    }
+                    await processOsmFile(table, temporaryFile, parameters, verbose);
+                }
+                finally {
+                    (0, node_fs_1.rmSync)(temporaryFile, { force: true });
+                    verbose &&
+                        console.log("Removed the temporary raw Overpass download.");
+                }
+            },
+        });
+        verbose && console.log(`loadOpenStreetMap(): completed in ${(0, prettyDuration_js_1.default)(started)}.`);
+    }
+    catch (error) {
+        if (error instanceof SDAError_js_1.default)
+            throw error;
+        throw new SDAError_js_1.default({
+            method: "loadOpenStreetMap()",
+            parameters,
+            query,
+            cause: error,
+        });
+    }
+}
+async function processOsmFile(table, file, parameters, verbose) {
+    verbose && console.log("Processing OSM data with Osmium...");
+    const started = Date.now();
+    try {
+        await (0, loadOsmFile_js_1.default)(table, file, {
+            method: "loadOpenStreetMap()",
+            parameters,
+        });
+    }
+    catch (error) {
+        const cause = error instanceof SDAError_js_1.default ? error.cause : error;
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        throw new Error(`${reason}\nNot retrying because Osmium or a downstream DuckDB operation rejected the source data.\nNo invalid cached data was returned.`, { cause: error });
+    }
+    if (verbose) {
+        const data = await (0, queryDB_js_1.default)(table, `SELECT count(*)::DOUBLE AS count FROM ${(0, quoteIdentifier_js_1.default)(table.name)};`, (0, mergeOptions_js_1.default)(table, {
+            table: table.name,
+            method: "loadOpenStreetMap()",
+            parameters,
+            returnData: true,
+        }));
+        const count = Number(data?.[0]?.count ?? 0);
+        console.log(`Processed ${count.toLocaleString("en-US")} rows in ${(0, prettyDuration_js_1.default)(started)}.`);
+    }
+}
+async function assertSuccessfulOverpassResponse(file) {
+    const contents = await Deno.readTextFile(file);
+    const match = /<(remark|error)\b[^>]*>([\s\S]*?)(?:<\/\1\s*>|$)/i.exec(contents);
+    if (match === null)
+        return;
+    const message = match[2]
+        .replace(/<[^>]*>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 500);
+    throw new Error(message.length === 0
+        ? "The Overpass endpoint returned an error response."
+        : `The Overpass endpoint returned an error response: ${message}`);
+}
+function generateOverpassQuery(bbox, filters, timeout) {
+    const box = `${bbox.south},${bbox.west},${bbox.north},${bbox.east}`;
+    const selections = filters.map((filter) => `nwr${filter}(${box});`);
+    const selection = selections.length === 1
+        ? selections[0]
+        : `(${selections.join("")});`;
+    return `[out:xml]${timeout === undefined ? "" : `[timeout:${timeout}]`};${selection}(._;>;);out body;`;
+}
+function normalizeBoundingBox(bbox) {
+    const normalized = structuredClone(bbox);
+    for (const [name, value] of Object.entries(normalized)) {
+        if (!Number.isFinite(value)) {
+            throw new Error(`loadOpenStreetMap() bbox.${name} must be a finite number.`);
+        }
+    }
+    if (normalized.west < -180 || normalized.west > 180) {
+        throw new Error("loadOpenStreetMap() bbox.west must be between -180 and 180.");
+    }
+    if (normalized.east < -180 || normalized.east > 180) {
+        throw new Error("loadOpenStreetMap() bbox.east must be between -180 and 180.");
+    }
+    if (normalized.south < -90 || normalized.south > 90) {
+        throw new Error("loadOpenStreetMap() bbox.south must be between -90 and 90.");
+    }
+    if (normalized.north < -90 || normalized.north > 90) {
+        throw new Error("loadOpenStreetMap() bbox.north must be between -90 and 90.");
+    }
+    if (normalized.west >= normalized.east) {
+        throw new Error("loadOpenStreetMap() bbox.west must be less than bbox.east.");
+    }
+    if (normalized.south >= normalized.north) {
+        throw new Error("loadOpenStreetMap() bbox.south must be less than bbox.north.");
+    }
+    normalized.west = Object.is(normalized.west, -0) ? 0 : normalized.west;
+    normalized.south = Object.is(normalized.south, -0) ? 0 : normalized.south;
+    normalized.east = Object.is(normalized.east, -0) ? 0 : normalized.east;
+    normalized.north = Object.is(normalized.north, -0) ? 0 : normalized.north;
+    return normalized;
+}
+function normalizeFilters(filters) {
+    if (typeof filters === "string") {
+        const filter = filters.trim();
+        if (filter.length === 0) {
+            throw new Error("loadOpenStreetMap() filters must contain at least one non-empty filter fragment.");
+        }
+        return [filter];
+    }
+    if (!Array.isArray(filters)) {
+        throw new TypeError("loadOpenStreetMap() options.filters is required.");
+    }
+    const tuples = isFilterTuple(filters) ? [filters] : filters;
+    const normalized = tuples.map(([key, value]) => {
+        if (typeof key !== "string" || typeof value !== "string") {
+            throw new TypeError("loadOpenStreetMap() filter tuples must contain two strings.");
+        }
+        if (key.length === 0) {
+            throw new Error("loadOpenStreetMap() filter keys must not be empty.");
+        }
+        return `[${JSON.stringify(key)}=${JSON.stringify(value)}]`;
+    });
+    if (normalized.length === 0) {
+        throw new Error("loadOpenStreetMap() filters must contain at least one filter tuple.");
+    }
+    return normalized;
+}
+function isFilterTuple(filters) {
+    return filters.length === 2 && typeof filters[0] === "string" &&
+        typeof filters[1] === "string";
+}
+function normalizeEndpoint(endpoint) {
+    try {
+        return (0, osmFiles_js_1.normalizeRemoteOsmUrl)(endpoint);
+    }
+    catch {
+        throw new Error("loadOpenStreetMap() endpoint must be a valid HTTP or HTTPS URL.");
+    }
+}
+function assertOptions(options, overpass) {
+    const allowed = new Set([
+        "cache",
+        "ttl",
+        "retries",
+        "retryDelay",
+        "verbose",
+        ...(overpass ? ["filters", "endpoint", "timeout"] : []),
+    ]);
+    const unsupported = Object.keys(options).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`loadOpenStreetMap() does not support ${unsupported.map((key) => `options.${key}`).join(", ")} for this source. Apply filtering and projection with normal table methods after loading.`);
+    }
+    if (options.cache !== undefined && typeof options.cache !== "boolean") {
+        throw new TypeError("loadOpenStreetMap() options.cache must be a boolean.");
+    }
+    if (options.verbose !== undefined && typeof options.verbose !== "boolean") {
+        throw new TypeError("loadOpenStreetMap() options.verbose must be a boolean.");
+    }
+    if (options.ttl !== undefined &&
+        (!Number.isFinite(options.ttl) || options.ttl < 0)) {
+        throw new Error("loadOpenStreetMap() options.ttl must be a finite, non-negative number of seconds.");
+    }
+    if (options.cache === false && options.ttl !== undefined) {
+        throw new Error("loadOpenStreetMap() options.cache cannot be false when options.ttl is set.");
+    }
+    if (options.retries !== undefined &&
+        (!Number.isInteger(options.retries) || options.retries < 0)) {
+        throw new Error("loadOpenStreetMap() options.retries must be a non-negative integer.");
+    }
+    if (options.retryDelay !== undefined &&
+        (!Number.isFinite(options.retryDelay) || options.retryDelay < 0)) {
+        throw new Error("loadOpenStreetMap() options.retryDelay must be a finite, non-negative number of seconds.");
+    }
+    if (overpass && options.timeout !== undefined &&
+        (!Number.isInteger(options.timeout) || options.timeout <= 0)) {
+        throw new Error("loadOpenStreetMap() options.timeout must be a positive integer in seconds.");
+    }
+}

package/esm/methods/loadOSM.d.ts

@@ -1,17 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-type BoundingBox = {
-    west: number;
-    south: number;
-    east: number;
-    north: number;
-};
-type LoadOsmOptions = {
-    filters: string | [string, string] | [string, string][];
-    endpoint?: string;
-    timeout?: number;
-    cache?: boolean;
-};
-export default function loadOSM(table: SimpleTable, bbox: BoundingBox, options: LoadOsmOptions): void;
-export declare function generateOverpassQuery(bbox: BoundingBox, filters: string[], timeout?: number): string;
-export {};
-//# sourceMappingURL=loadOSM.d.ts.map

package/esm/methods/loadOSM.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadOSM.d.ts","sourceRoot":"","sources":["../../src/methods/loadOSM.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,GACtB,IAAI,CAkBN;AAgHD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,CASR"}

package/esm/methods/loadOSM.js

@@ -1,194 +0,0 @@
-import { createReadStream, rmSync } from "node:fs";
-import SDAError from "../class/SDAError.js";
-import loadOsmFile from "../helpers/loadOsmFile.js";
-import { createOsmCacheId, useProcessedOsmCache } from "../helpers/osmCache.js";
-import { downloadOsmToTemporaryFile } from "../helpers/osmFiles.js";
-import queueOp from "../helpers/queueOp.js";
-const DEFAULT_OVERPASS_ENDPOINT = "https://overpass-api.de/api/interpreter";
-const QUERY_GENERATOR_VERSION = "overpass-ql-v1";
-export default function loadOSM(table, bbox, options) {
-    bbox = normalizeBoundingBox(bbox);
-    options = structuredClone(options);
-    const endpoint = normalizeEndpoint(options.endpoint ?? DEFAULT_OVERPASS_ENDPOINT);
-    const filters = normalizeFilters(options.filters);
-    assertTimeout(options.timeout);
-    const query = generateOverpassQuery(bbox, filters, options.timeout);
-    const parameters = { bbox, options };
-    queueOp(table, {
-        kind: "barrier",
-        method: "loadOSM()",
-        parameters,
-        execute: () => executeLoadOSM(table, bbox, options, endpoint, query, parameters),
-    });
-}
-async function executeLoadOSM(table, bbox, options, endpoint, query, parameters) {
-    try {
-        const cacheEnabled = options.cache ?? true;
-        const cacheId = createOsmCacheId({
-            endpoint,
-            bbox,
-            query,
-            queryGeneratorVersion: QUERY_GENERATOR_VERSION,
-        });
-        await useProcessedOsmCache(table, cacheId, cacheEnabled, parameters, async () => {
-            const timeoutSignal = options.timeout === undefined
-                ? undefined
-                : AbortSignal.timeout(options.timeout * 1000);
-            const body = new URLSearchParams({ data: query });
-            const temporaryFile = await downloadOsmToTemporaryFile(endpoint, {
-                suffix: ".osm",
-                prefix: cacheId,
-                request: {
-                    method: "POST",
-                    headers: {
-                        "accept-encoding": "gzip",
-                        "content-type": "application/x-www-form-urlencoded;charset=UTF-8",
-                        "user-agent": "simple-data-analysis-core (https://github.com/nshiab/simple-data-analysis-core)",
-                    },
-                    body,
-                    signal: timeoutSignal,
-                },
-            });
-            try {
-                await assertSuccessfulOverpassResponse(temporaryFile);
-                await loadOsmFile(table, temporaryFile, {
-                    method: "loadOSM()",
-                    parameters,
-                });
-            }
-            finally {
-                rmSync(temporaryFile, { force: true });
-            }
-        });
-    }
-    catch (error) {
-        if (error instanceof SDAError) {
-            throw error;
-        }
-        throw new SDAError({
-            method: "loadOSM()",
-            parameters,
-            query,
-            cause: error,
-        });
-    }
-}
-async function assertSuccessfulOverpassResponse(file) {
-    const stream = createReadStream(file, { encoding: "utf-8" });
-    let buffer = "";
-    let errorTag;
-    for await (const chunk of stream) {
-        buffer += String(chunk);
-        if (errorTag === undefined) {
-            const openingTag = /<(remark|error)\b[^>]*>/i.exec(buffer);
-            if (openingTag === null) {
-                buffer = buffer.slice(-4096);
-                continue;
-            }
-            errorTag = openingTag[1].toLowerCase() === "remark" ? "remark" : "error";
-            buffer = buffer.slice(openingTag.index + openingTag[0].length);
-        }
-        const closingTag = new RegExp(`</${errorTag}\\s*>`, "i").exec(buffer);
-        if (closingTag !== null) {
-            throwOverpassResponseError(buffer.slice(0, closingTag.index));
-        }
-        if (buffer.length >= 4096) {
-            throwOverpassResponseError(buffer.slice(0, 4096));
-        }
-    }
-    if (errorTag !== undefined) {
-        throwOverpassResponseError(buffer);
-    }
-}
-function throwOverpassResponseError(contents) {
-    const message = contents
-        .replace(/<[^>]*>/g, " ")
-        .replace(/\s+/g, " ")
-        .trim()
-        .slice(0, 500);
-    throw new Error(message.length === 0
-        ? "The Overpass endpoint returned an error response."
-        : `The Overpass endpoint returned an error response: ${message}`);
-}
-export function generateOverpassQuery(bbox, filters, timeout) {
-    const box = `${bbox.south},${bbox.west},${bbox.north},${bbox.east}`;
-    const selections = filters.map((filter) => `nwr${filter}(${box});`);
-    const selection = selections.length === 1
-        ? selections[0]
-        : `(${selections.join("")});`;
-    return `[out:xml]${timeout === undefined ? "" : `[timeout:${timeout}]`};${selection}(._;>;);out body;`;
-}
-function normalizeBoundingBox(bbox) {
-    const normalized = structuredClone(bbox);
-    for (const [name, value] of Object.entries(normalized)) {
-        if (!Number.isFinite(value)) {
-            throw new Error(`loadOSM() bbox.${name} must be a finite number.`);
-        }
-    }
-    if (normalized.west < -180 || normalized.west > 180) {
-        throw new Error("loadOSM() bbox.west must be between -180 and 180.");
-    }
-    if (normalized.east < -180 || normalized.east > 180) {
-        throw new Error("loadOSM() bbox.east must be between -180 and 180.");
-    }
-    if (normalized.south < -90 || normalized.south > 90) {
-        throw new Error("loadOSM() bbox.south must be between -90 and 90.");
-    }
-    if (normalized.north < -90 || normalized.north > 90) {
-        throw new Error("loadOSM() bbox.north must be between -90 and 90.");
-    }
-    if (normalized.west >= normalized.east) {
-        throw new Error("loadOSM() bbox.west must be less than bbox.east.");
-    }
-    if (normalized.south >= normalized.north) {
-        throw new Error("loadOSM() bbox.south must be less than bbox.north.");
-    }
-    normalized.west = Object.is(normalized.west, -0) ? 0 : normalized.west;
-    normalized.south = Object.is(normalized.south, -0) ? 0 : normalized.south;
-    normalized.east = Object.is(normalized.east, -0) ? 0 : normalized.east;
-    normalized.north = Object.is(normalized.north, -0) ? 0 : normalized.north;
-    return normalized;
-}
-function normalizeFilters(filters) {
-    if (typeof filters === "string") {
-        const filter = filters.trim();
-        if (filter.length === 0) {
-            throw new Error("loadOSM() filters must contain at least one non-empty filter fragment.");
-        }
-        return [filter];
-    }
-    const tuples = isFilterTuple(filters) ? [filters] : filters;
-    const normalized = tuples.map(([key, value]) => {
-        if (key.length === 0) {
-            throw new Error("loadOSM() filter keys must not be empty.");
-        }
-        return `[${JSON.stringify(key)}=${JSON.stringify(value)}]`;
-    });
-    if (normalized.length === 0) {
-        throw new Error("loadOSM() filters must contain at least one filter tuple.");
-    }
-    return normalized;
-}
-function isFilterTuple(filters) {
-    return filters.length === 2 && typeof filters[0] === "string" &&
-        typeof filters[1] === "string";
-}
-function normalizeEndpoint(endpoint) {
-    let url;
-    try {
-        url = new URL(endpoint);
-    }
-    catch {
-        throw new Error("loadOSM() endpoint must be a valid HTTP or HTTPS URL.");
-    }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error("loadOSM() endpoint must be an HTTP or HTTPS URL.");
-    }
-    return url.toString();
-}
-function assertTimeout(timeout) {
-    if (timeout !== undefined &&
-        (!Number.isInteger(timeout) || timeout <= 0)) {
-        throw new Error("loadOSM() timeout must be a positive integer in seconds.");
-    }
-}

package/script/methods/loadOSM.d.ts

@@ -1,17 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-type BoundingBox = {
-    west: number;
-    south: number;
-    east: number;
-    north: number;
-};
-type LoadOsmOptions = {
-    filters: string | [string, string] | [string, string][];
-    endpoint?: string;
-    timeout?: number;
-    cache?: boolean;
-};
-export default function loadOSM(table: SimpleTable, bbox: BoundingBox, options: LoadOsmOptions): void;
-export declare function generateOverpassQuery(bbox: BoundingBox, filters: string[], timeout?: number): string;
-export {};
-//# sourceMappingURL=loadOSM.d.ts.map

package/script/methods/loadOSM.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadOSM.d.ts","sourceRoot":"","sources":["../../src/methods/loadOSM.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,GACtB,IAAI,CAkBN;AAgHD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,CASR"}