@chelone/core 0.6.0 → 0.9.0

package/dist/geo/map-style.js

@@ -1,39 +1,50 @@
+// src/geo/map-style.ts
+/** MapLibre has no `{s}` support, so a template with one becomes three URLs. */
 function expandTileUrl(url) {
-  if (!url.includes("{s}")) return [url];
-  return ["a", "b", "c"].map((host) => url.replaceAll("{s}", host));
+	if (!url.includes("{s}")) return [url];
+	return [
+		"a",
+		"b",
+		"c"
+	].map((host) => url.replaceAll("{s}", host));
 }
-function rasterTileStyle({
-  tileUrl,
-  attribution,
-  maxZoom = 19
-}) {
-  if (!tileUrl) throw new TypeError("rasterTileStyle: tileUrl is required");
-  if (!attribution) {
-    throw new TypeError("rasterTileStyle: attribution is required");
-  }
-  return {
-    version: 8,
-    sources: {
-      basemap: {
-        type: "raster",
-        tiles: expandTileUrl(tileUrl),
-        tileSize: 256,
-        maxzoom: maxZoom,
-        attribution
-      }
-    },
-    layers: [{ id: "basemap", type: "raster", source: "basemap" }]
-  };
+function rasterTileStyle({ tileUrl, attribution, maxZoom = 19 }) {
+	if (!tileUrl) throw new TypeError("rasterTileStyle: tileUrl is required");
+	if (!attribution) throw new TypeError("rasterTileStyle: attribution is required");
+	return {
+		version: 8,
+		sources: { basemap: {
+			type: "raster",
+			tiles: expandTileUrl(tileUrl),
+			tileSize: 256,
+			maxzoom: maxZoom,
+			attribution
+		} },
+		layers: [{
+			id: "basemap",
+			type: "raster",
+			source: "basemap"
+		}]
+	};
 }
+/** The zoom a map view builds when the app passes none. */
+var DEFAULT_MAP_ZOOM = 13;
+/** The height in pixels a map view builds when the app passes none. */
+var DEFAULT_MAP_HEIGHT = 300;
+/** The pixels a bounds fit keeps free around the box when the app passes none. */
+var DEFAULT_FIT_PADDING = 20;
+/** The highest zoom a bounds fit may reach when the app passes none. */
+var DEFAULT_MAX_FIT_ZOOM = 18;
+/** The pin fill a map marker uses when the app passes no color. */
+var DEFAULT_PIN_COLOR = "#dc2626";
+/** The SVG namespace, for building a pin element without a map library. */
+var PIN_NS = "http://www.w3.org/2000/svg";
+/** `[lat, lng]` (what components take) to MapLibre's `[lng, lat]`. */
 function latLngToLngLat(latLng) {
-  return [latLng[1], latLng[0]];
+	return [latLng[1], latLng[0]];
 }
+/** MapLibre's `[lng, lat]` to `[lat, lng]`. */
 function lngLatToLatLng(lngLat) {
-  return [lngLat[1], lngLat[0]];
+	return [lngLat[1], lngLat[0]];
 }
-export {
-  expandTileUrl,
-  latLngToLngLat,
-  lngLatToLatLng,
-  rasterTileStyle
-};
+export { DEFAULT_FIT_PADDING, DEFAULT_MAP_HEIGHT, DEFAULT_MAP_ZOOM, DEFAULT_MAX_FIT_ZOOM, DEFAULT_PIN_COLOR, PIN_NS, expandTileUrl, latLngToLngLat, lngLatToLatLng, rasterTileStyle };

package/dist/geo/messages.js

@@ -1,47 +1,50 @@
 import { defineMessages } from "../i18n/messages.js";
-const mapMessages = defineMessages({
-  "chelone.map.load_failed": "The map could not be loaded",
-  "chelone.map.no_coordinates": "No coordinates",
-  "chelone.map.no_geometry": "No geometry",
-  "chelone.map.shape_not_shown": "Part of this shape cannot be shown on the map",
-  "chelone.map.snap_failed": "The line could not be snapped to roads",
-  "chelone.map.toolbar": "Map tools",
-  "chelone.map.tool.draw_point": "Draw a point",
-  "chelone.map.tool.draw_line": "Draw a line",
-  "chelone.map.tool.draw_polygon": "Draw a polygon",
-  "chelone.map.tool.draw_rectangle": "Draw a rectangle",
-  "chelone.map.tool.draw_circle": "Draw a circle",
-  "chelone.map.tool.edit": "Edit",
-  "chelone.map.tool.move": "Move",
-  "chelone.map.tool.delete": "Delete",
-  "chelone.map.tool.cut": "Cut a hole",
-  "chelone.map.search_placeholder": "Search for a place",
-  "chelone.map.search_button": "Search",
-  "chelone.map.searching": "Searching...",
-  "chelone.map.no_results": "No results",
-  "chelone.map.search_failed": "The search failed, try again shortly",
-  "chelone.map.simplify.tolerance": "Tolerance: {value}",
-  "chelone.map.simplify.default": "Default",
-  "chelone.map.simplify.high": "High",
-  "chelone.map.osm.subtract": "Subtract OpenStreetMap areas",
-  "chelone.map.osm.add": "Add OpenStreetMap areas",
-  "chelone.map.osm.no_sources": "No OpenStreetMap sources configured",
-  "chelone.map.osm.no_polygon": "Draw a polygon first",
-  "chelone.map.osm.no_match": "No matching OpenStreetMap area found",
-  "chelone.map.osm.covered": "The polygon is already covered",
-  "chelone.map.osm.subtracted": "Subtracted {area}",
-  "chelone.map.osm.added": "Added {area}",
-  "chelone.map.osm.would_split": "The result has more than one piece, so the polygon was left as it was",
-  "chelone.map.osm.union_empty": "The union is empty",
-  "chelone.map.osm.error": "OpenStreetMap request failed",
-  "chelone.map.osm.rate_limited": "OpenStreetMap is rate limiting requests, try again shortly",
-  "chelone.validation.latitude": "Must be a latitude between -90 and 90",
-  "chelone.validation.longitude": "Must be a longitude between -180 and 180",
-  "chelone.validation.minVertices": "Must have at least {min} vertices",
-  "chelone.validation.maxVertices": "Must have {max} vertices or fewer",
-  "chelone.validation.minArea": "Area {area} is below the minimum of {min}",
-  "chelone.validation.selfIntersection": "Must not cross itself"
+// src/geo/messages.ts
+/**
+* English text for the map add-on. Spread next to `defaultMessages`:
+* `{ ...defaultMessages, ...mapMessages }`. Shares no key with it.
+*/
+var mapMessages = defineMessages({
+	"chelone.map.load_failed": "The map could not be loaded",
+	"chelone.map.no_coordinates": "No coordinates",
+	"chelone.map.no_geometry": "No geometry",
+	"chelone.map.shape_not_shown": "Part of this shape cannot be shown on the map",
+	"chelone.map.snap_failed": "The line could not be snapped to roads",
+	"chelone.map.toolbar": "Map tools",
+	"chelone.map.tool.draw_point": "Draw a point",
+	"chelone.map.tool.draw_line": "Draw a line",
+	"chelone.map.tool.draw_polygon": "Draw a polygon",
+	"chelone.map.tool.draw_rectangle": "Draw a rectangle",
+	"chelone.map.tool.draw_circle": "Draw a circle",
+	"chelone.map.tool.edit": "Edit",
+	"chelone.map.tool.move": "Move",
+	"chelone.map.tool.delete": "Delete",
+	"chelone.map.tool.cut": "Cut a hole",
+	"chelone.map.search_placeholder": "Search for a place",
+	"chelone.map.search_button": "Search",
+	"chelone.map.searching": "Searching...",
+	"chelone.map.no_results": "No results",
+	"chelone.map.search_failed": "The search failed, try again shortly",
+	"chelone.map.simplify.tolerance": "Tolerance: {value}",
+	"chelone.map.simplify.default": "Default",
+	"chelone.map.simplify.high": "High",
+	"chelone.map.osm.subtract": "Subtract OpenStreetMap areas",
+	"chelone.map.osm.add": "Add OpenStreetMap areas",
+	"chelone.map.osm.no_sources": "No OpenStreetMap sources configured",
+	"chelone.map.osm.no_polygon": "Draw a polygon first",
+	"chelone.map.osm.no_match": "No matching OpenStreetMap area found",
+	"chelone.map.osm.covered": "The polygon is already covered",
+	"chelone.map.osm.subtracted": "Subtracted {area}",
+	"chelone.map.osm.added": "Added {area}",
+	"chelone.map.osm.would_split": "The result has more than one piece, so the polygon was left as it was",
+	"chelone.map.osm.union_empty": "The union is empty",
+	"chelone.map.osm.error": "OpenStreetMap request failed",
+	"chelone.map.osm.rate_limited": "OpenStreetMap is rate limiting requests, try again shortly",
+	"chelone.validation.latitude": "Must be a latitude between -90 and 90",
+	"chelone.validation.longitude": "Must be a longitude between -180 and 180",
+	"chelone.validation.minVertices": "Must have at least {min} vertices",
+	"chelone.validation.maxVertices": "Must have {max} vertices or fewer",
+	"chelone.validation.minArea": "Area {area} is below the minimum of {min}",
+	"chelone.validation.selfIntersection": "Must not cross itself"
 });
-export {
-  mapMessages
-};
+export { mapMessages };

package/dist/geo/nominatim.js

@@ -1,87 +1,95 @@
+import { isRecord } from "../guards.js";
 import { createThrottle } from "./throttle.js";
+// src/geo/nominatim.ts
+/** `Number(null)` and `Number("")` are 0; a missing coordinate must not be. */
 function toNumber(value) {
-  if (typeof value === "number") return value;
-  if (typeof value === "string" && value.trim() !== "") return Number(value);
-  return Number.NaN;
+	if (typeof value === "number") return value;
+	if (typeof value === "string" && value.trim() !== "") return Number(value);
+	return NaN;
 }
 function toResult(hit) {
-  if (typeof hit.display_name !== "string") return null;
-  const lat = toNumber(hit.lat);
-  const lng = toNumber(hit.lon);
-  if (!Number.isFinite(lat) || !Number.isFinite(lng)) return null;
-  const result = { displayName: hit.display_name, lat, lng };
-  if (Array.isArray(hit.boundingbox) && hit.boundingbox.length === 4) {
-    const [minLat, maxLat, minLon, maxLon] = hit.boundingbox.map(toNumber);
-    const bbox = [minLon, minLat, maxLon, maxLat];
-    if (bbox.every(Number.isFinite)) result.bbox = bbox;
-  }
-  if (typeof hit.type === "string") result.type = hit.type;
-  result.raw = hit;
-  return result;
+	if (typeof hit.display_name !== "string") return null;
+	const lat = toNumber(hit.lat);
+	const lng = toNumber(hit.lon);
+	if (!Number.isFinite(lat) || !Number.isFinite(lng)) return null;
+	const result = {
+		displayName: hit.display_name,
+		lat,
+		lng
+	};
+	if (Array.isArray(hit.boundingbox) && hit.boundingbox.length === 4) {
+		const [minLat = NaN, maxLat = NaN, minLon = NaN, maxLon = NaN] = hit.boundingbox.map(toNumber);
+		const bbox = [
+			minLon,
+			minLat,
+			maxLon,
+			maxLat
+		];
+		if (bbox.every(Number.isFinite)) result.bbox = bbox;
+	}
+	if (typeof hit.type === "string") result.type = hit.type;
+	result.raw = hit;
+	return result;
 }
 function createNominatimProvider(options) {
-  const { endpoint } = options;
-  if (typeof endpoint !== "string" || endpoint.trim() === "") {
-    throw new TypeError(
-      'createNominatimProvider: the "endpoint" option is required'
-    );
-  }
-  const base = endpoint.trim().replace(/\/+$/, "");
-  const language = options.language ?? "en";
-  const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
-  const throttle = createThrottle({
-    minIntervalMs: options.minIntervalMs ?? 1e3,
-    now: options.now,
-    sleep: options.sleep
-  });
-  const get = async (path, params, signal) => {
-    await throttle.wait(signal);
-    return doFetch(`${base}/${path}?${params}`, {
-      headers: { "Accept-Language": language },
-      signal
-    });
-  };
-  return {
-    name: "nominatim",
-    cacheKey: `nominatim|${base}|${language}`,
-    typeahead: options.typeahead ?? false,
-    async search(query, searchOptions = {}) {
-      const { signal, limit = 10, countryCodes, viewBox } = searchOptions;
-      const params = new URLSearchParams({
-        q: query,
-        format: "json",
-        limit: String(limit)
-      });
-      if (countryCodes?.length) {
-        params.set("countrycodes", countryCodes.join(","));
-      }
-      if (viewBox) params.set("viewbox", viewBox.join(","));
-      const response = await get("search", params, signal);
-      if (!response.ok) throw new Error(`Nominatim search ${response.status}`);
-      const hits = await response.json();
-      if (!Array.isArray(hits)) return [];
-      return hits.flatMap((hit) => toResult(hit) ?? []);
-    },
-    async reverse(lat, lng, reverseOptions = {}) {
-      const { signal } = reverseOptions;
-      const params = new URLSearchParams({
-        lat: String(lat),
-        lon: String(lng),
-        format: "json"
-      });
-      try {
-        const response = await get("reverse", params, signal);
-        if (!response.ok) return null;
-        const body = await response.json();
-        if (!body || body.error) return null;
-        return toResult(body);
-      } catch (error) {
-        if (signal?.aborted) throw error;
-        return null;
-      }
-    }
-  };
+	const { endpoint } = options;
+	if (typeof endpoint !== "string" || endpoint.trim() === "") throw new TypeError("createNominatimProvider: the \"endpoint\" option is required");
+	const base = endpoint.trim().replace(/\/+$/, "");
+	const language = options.language ?? "en";
+	const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	const throttle = createThrottle({
+		minIntervalMs: options.minIntervalMs ?? 1e3,
+		now: options.now,
+		sleep: options.sleep
+	});
+	const get = async (path, params, signal) => {
+		await throttle.wait(signal);
+		return doFetch(`${base}/${path}?${params}`, {
+			headers: { "Accept-Language": language },
+			signal
+		});
+	};
+	return {
+		name: "nominatim",
+		cacheKey: `nominatim|${base}|${language}`,
+		typeahead: options.typeahead ?? false,
+		async search(query, searchOptions = {}) {
+			const { signal, limit = 10, countryCodes, viewBox } = searchOptions;
+			const params = new URLSearchParams({
+				q: query,
+				format: "json",
+				limit: String(limit)
+			});
+			if (countryCodes?.length) params.set("countrycodes", countryCodes.join(","));
+			if (viewBox) params.set("viewbox", viewBox.join(","));
+			const response = await get("search", params, signal);
+			if (!response.ok) throw new Error(`Nominatim search ${response.status}`);
+			const hits = await response.json();
+			if (!Array.isArray(hits)) return [];
+			return hits.flatMap((hit) => {
+				if (!isRecord(hit)) return [];
+				const result = toResult(hit);
+				return result ? [result] : [];
+			});
+		},
+		async reverse(lat, lng, reverseOptions = {}) {
+			const { signal } = reverseOptions;
+			const params = new URLSearchParams({
+				lat: String(lat),
+				lon: String(lng),
+				format: "json"
+			});
+			try {
+				const response = await get("reverse", params, signal);
+				if (!response.ok) return null;
+				const body = await response.json();
+				if (!isRecord(body) || body.error) return null;
+				return toResult(body);
+			} catch (error) {
+				if (signal?.aborted) throw error;
+				return null;
+			}
+		}
+	};
 }
-export {
-  createNominatimProvider
-};
+export { createNominatimProvider };

package/dist/geo/osm-presets.d.ts

@@ -1,4 +1,5 @@
-import type { GeoBBox } from "./geojson.js";
+import type { JsonObject } from "../guards.js";
+import type { LngLatBox } from "./bounds.js";
 import type { OsmTagFilter, OsmTagInput } from "./osm-tags.js";
 export type OsmElementType = "way" | "relation";
 export interface OsmPreset {
@@ -74,7 +75,7 @@ export type OsmPresetName = keyof typeof OSM_PRESETS;
  * The first of `names` with a filter that accepts the feature's tags, so an
  * adapter can read its `bufferLinesMeters`; `null` when none does.
  */
-export declare function findPresetForTags(tags: Readonly<Record<string, unknown>>, names: readonly OsmPresetName[]): OsmPreset | null;
+export declare function findPresetForTags(tags: Readonly<JsonObject>, names: readonly OsmPresetName[]): OsmPreset | null;
 export interface OverpassQuerySources {
     presets?: readonly OsmPresetName[];
     tags?: readonly OsmTagInput[];
@@ -83,4 +84,4 @@ export interface OverpassQuerySources {
  * Overpass QL for every feature matching a preset or a tag inside `bbox`
  * (`[west, south, east, north]`, written south, west, north, east).
  */
-export declare function buildOverpassQuery(sources: OverpassQuerySources, bbox: GeoBBox): string;
+export declare function buildOverpassQuery(sources: OverpassQuerySources, bbox: LngLatBox): string;

package/dist/geo/osm-presets.js

@@ -1,98 +1,120 @@
 import { tagToFilter } from "./osm-tags.js";
-const anyOf = (key) => ({ filters: [{ key, any: true }] });
-const OSM_PRESETS = {
-  water: {
-    filters: [
-      { key: "natural", values: ["water", "bay", "strait"] },
-      { key: "waterway", any: true }
-    ]
-  },
-  buildings: anyOf("building"),
-  forest: {
-    filters: [
-      { key: "natural", values: ["wood", "forest"] },
-      { key: "landuse", value: "forest" }
-    ]
-  },
-  roads: {
-    filters: [
-      { key: "highway", values: ["motorway", "trunk", "primary", "secondary"] }
-    ],
-    bufferLinesMeters: 15,
-    elementTypes: ["way"]
-  },
-  natural: anyOf("natural"),
-  building: anyOf("building"),
-  landuse: anyOf("landuse"),
-  amenity: anyOf("amenity"),
-  leisure: anyOf("leisure"),
-  boundary: anyOf("boundary"),
-  place: anyOf("place"),
-  man_made: anyOf("man_made"),
-  shop: anyOf("shop"),
-  tourism: anyOf("tourism"),
-  historic: anyOf("historic"),
-  highway: anyOf("highway"),
-  railway: { ...anyOf("railway"), bufferLinesMeters: 5, elementTypes: ["way"] },
-  waterway: { ...anyOf("waterway"), bufferLinesMeters: 5 },
-  barrier: { ...anyOf("barrier"), bufferLinesMeters: 3 },
-  power: { ...anyOf("power"), bufferLinesMeters: 3 }
+// src/geo/osm-presets.ts
+var anyOf = (key) => ({ filters: [{
+	key,
+	any: true
+}] });
+var OSM_PRESETS = {
+	water: { filters: [{
+		key: "natural",
+		values: [
+			"water",
+			"bay",
+			"strait"
+		]
+	}, {
+		key: "waterway",
+		any: true
+	}] },
+	buildings: anyOf("building"),
+	forest: { filters: [{
+		key: "natural",
+		values: ["wood", "forest"]
+	}, {
+		key: "landuse",
+		value: "forest"
+	}] },
+	roads: {
+		filters: [{
+			key: "highway",
+			values: [
+				"motorway",
+				"trunk",
+				"primary",
+				"secondary"
+			]
+		}],
+		bufferLinesMeters: 15,
+		elementTypes: ["way"]
+	},
+	natural: anyOf("natural"),
+	building: anyOf("building"),
+	landuse: anyOf("landuse"),
+	amenity: anyOf("amenity"),
+	leisure: anyOf("leisure"),
+	boundary: anyOf("boundary"),
+	place: anyOf("place"),
+	man_made: anyOf("man_made"),
+	shop: anyOf("shop"),
+	tourism: anyOf("tourism"),
+	historic: anyOf("historic"),
+	highway: anyOf("highway"),
+	railway: {
+		...anyOf("railway"),
+		bufferLinesMeters: 5,
+		elementTypes: ["way"]
+	},
+	waterway: {
+		...anyOf("waterway"),
+		bufferLinesMeters: 5
+	},
+	barrier: {
+		...anyOf("barrier"),
+		bufferLinesMeters: 3
+	},
+	power: {
+		...anyOf("power"),
+		bufferLinesMeters: 3
+	}
 };
 function accepts(filter, tags) {
-  const raw = tags[filter.key];
-  if (raw === void 0 || raw === null) return false;
-  if ("any" in filter) return true;
-  const actual = String(raw);
-  return "values" in filter ? filter.values.includes(actual) : filter.value === actual;
+	const raw = tags[filter.key];
+	if (raw === void 0 || raw === null) return false;
+	if ("any" in filter) return true;
+	const actual = String(raw);
+	return "values" in filter ? filter.values.includes(actual) : filter.value === actual;
 }
+/**
+* The first of `names` with a filter that accepts the feature's tags, so an
+* adapter can read its `bufferLinesMeters`; `null` when none does.
+*/
 function findPresetForTags(tags, names) {
-  for (const name of names) {
-    const preset = OSM_PRESETS[name];
-    if (preset.filters.some((filter) => accepts(filter, tags))) return preset;
-  }
-  return null;
+	for (const name of names) {
+		const preset = OSM_PRESETS[name];
+		if (preset.filters.some((filter) => accepts(filter, tags))) return preset;
+	}
+	return null;
 }
+/** Escapes for an Overpass string; a newline cannot be escaped, so it throws. */
 function quote(text) {
-  if (/[\r\n]/.test(text)) {
-    throw new TypeError("An OSM tag cannot contain a newline");
-  }
-  return `"${text.replace(/[\\"]/g, "\\$&")}"`;
+	if (/[\r\n]/.test(text)) throw new TypeError("An OSM tag cannot contain a newline");
+	return `"${text.replace(/[\\"]/g, "\\$&")}"`;
 }
-const regexLiteral = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** A regex alternative must match its text literally. */
+var regexLiteral = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function filterToSelector(filter) {
-  const key = quote(filter.key);
-  if ("any" in filter) return `[${key}]`;
-  if ("values" in filter) {
-    const alternatives = filter.values.map(regexLiteral).join("|");
-    return `[${key}~${quote(`^(${alternatives})$`)}]`;
-  }
-  return `[${key}=${quote(filter.value)}]`;
+	const key = quote(filter.key);
+	if ("any" in filter) return `[${key}]`;
+	if ("values" in filter) return `[${key}~${quote(`^(${filter.values.map(regexLiteral).join("|")})$`)}]`;
+	return `[${key}=${quote(filter.value)}]`;
 }
+/**
+* Overpass QL for every feature matching a preset or a tag inside `bbox`
+* (`[west, south, east, north]`, written south, west, north, east).
+*/
 function buildOverpassQuery(sources, bbox) {
-  const [west, south, east, north] = bbox;
-  const area = `(${south},${west},${north},${east})`;
-  const clauses = [];
-  const add = (filter, types) => {
-    const selector = filterToSelector(filter);
-    for (const type of types) clauses.push(`  ${type}${selector}${area};`);
-  };
-  for (const name of sources.presets ?? []) {
-    const preset = OSM_PRESETS[name];
-    for (const filter of preset.filters) {
-      add(filter, preset.elementTypes ?? ["way", "relation"]);
-    }
-  }
-  for (const tag of sources.tags ?? [])
-    add(tagToFilter(tag), ["way", "relation"]);
-  const union = clauses.length ? `(
-${clauses.join("\n")}
-);` : "();";
-  return `[out:json][timeout:25];
-${union}
-out geom;`;
+	const [west, south, east, north] = bbox;
+	const area = `(${south},${west},${north},${east})`;
+	const clauses = [];
+	const add = (filter, types) => {
+		const selector = filterToSelector(filter);
+		for (const type of types) clauses.push(`  ${type}${selector}${area};`);
+	};
+	for (const name of sources.presets ?? []) {
+		const preset = OSM_PRESETS[name];
+		for (const filter of preset.filters) add(filter, preset.elementTypes ?? ["way", "relation"]);
+	}
+	for (const tag of sources.tags ?? []) add(tagToFilter(tag), ["way", "relation"]);
+	return `[out:json][timeout:25];\n${clauses.length ? `(\n${clauses.join("\n")}\n);` : "();"}\nout geom;`;
 }
-export {
-  OSM_PRESETS,
-  buildOverpassQuery,
-  findPresetForTags
-};
+export { OSM_PRESETS, buildOverpassQuery, findPresetForTags };

package/dist/geo/osm-tags.js

@@ -1,14 +1,16 @@
+// src/geo/osm-tags.ts
+/** `natural=water` is `{ key, value }`; `building=*` matches any value. */
 function tagToFilter(tag) {
-  const separator = tag.indexOf("=");
-  const key = separator < 0 ? "" : tag.slice(0, separator).trim();
-  const value = separator < 0 ? "" : tag.slice(separator + 1).trim();
-  if (!key || !value) {
-    throw new TypeError(
-      `Invalid OSM tag "${tag}": expected "key=value" or "key=*"`
-    );
-  }
-  return value === "*" ? { key, any: true } : { key, value };
+	const separator = tag.indexOf("=");
+	const key = separator < 0 ? "" : tag.slice(0, separator).trim();
+	const value = separator < 0 ? "" : tag.slice(separator + 1).trim();
+	if (!key || !value) throw new TypeError(`Invalid OSM tag "${tag}": expected "key=value" or "key=*"`);
+	return value === "*" ? {
+		key,
+		any: true
+	} : {
+		key,
+		value
+	};
 }
-export {
-  tagToFilter
-};
+export { tagToFilter };