@osm-editor-kit/osm-route-snapper 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,47 @@
+# `@osm-editor-kit/osm-route-snapper`
+
+**Status:** First npm **alpha** (`0.1.0-alpha.0`). Publish with `bun run packages:release -- --publish-only` after `npm login`.
+
+## What it does
+
+Bridge between merged session `ParsedOsmData` (`@osm-editor-kit/osm-data`) and the [route-snapper](https://github.com/a-b-street/route-snapper) routing graph:
+
+- Build route-snapper **bincode graph bytes** from Overpass/session coverage via vendored `osm-to-route-snapper` WASM
+- Serialize parsed OSM to minimal OSM XML for graph conversion
+- Extract **routing-network GeoJSON** (intersection-split edges) from graph bytes
+- GeoJSON LineStrings for session highway ways and a **coverage graph signature** for cache keys
+- TanStack Query factory that rebuilds the graph when Overpass coverage grows
+
+## Usage
+
+```ts
+import {
+  buildRouteSnapperGraphBytes,
+  createRouteSnapperGraphApi,
+  parsedOsmWaysToFeatureCollection,
+  routingNetworkGeoJsonFromBytes,
+} from '@osm-editor-kit/osm-route-snapper'
+```
+
+**Direct graph build** — pass merged `ParsedOsmData`; returns `Uint8Array` bincode or `null` when there are no ways:
+
+```ts
+const graphBytes = await buildRouteSnapperGraphBytes(parsedOsm)
+const routingNetwork = graphBytes
+  ? await routingNetworkGeoJsonFromBytes(graphBytes)
+  : null
+```
+
+**React + TanStack Query** — `createRouteSnapperGraphApi` wires coverage growth to automatic full rebuilds (WASM has no incremental API):
+
+```ts
+const { useRouteSnapperGraphQuery } = createRouteSnapperGraphApi({
+  getGraphKey: () => ['route-snapper-graph'],
+  useCoverageGraph: () => useSessionParsedOsm(),
+})
+```
+
+**Usage notes**
+
+- Graph conversion uses vendored `osm-to-route-snapper` WASM; routing-network GeoJSON uses the peer **`route-snapper`** package (`^0.4.9`) — install both in the app.
+- Peer deps: `react`, `@tanstack/react-query`, `route-snapper`.

package/dist/build-graph.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedOsmData } from '@osm-editor-kit/osm-data';
+/**
+ * Convert merged session OSM coverage into route-snapper bincode graph bytes.
+ * Uses prebuilt osm-to-route-snapper WASM (no Rust fork) — full rebuild from the
+ * current ParsedOsmData whenever coverage grows (WASM has no incremental merge API).
+ */
+export declare function buildRouteSnapperGraphBytes(data: ParsedOsmData): Promise<Uint8Array<ArrayBufferLike> | null>;

package/dist/create-route-snapper-graph-api.d.ts

@@ -0,0 +1,25 @@
+import type { ParsedOsmData } from '@osm-editor-kit/osm-data';
+import type { FeatureCollection, LineString } from 'geojson';
+export type RouteSnapperGraphData = {
+    graphBytes: Uint8Array | null;
+    wayCount: number;
+    edgeCount: number;
+    overpassWays: FeatureCollection<LineString>;
+    routingNetwork: FeatureCollection<LineString>;
+    lastError: string | null;
+};
+export declare function emptyRouteSnapperGraphData(): RouteSnapperGraphData;
+export type CreateRouteSnapperGraphApiOptions = {
+    /** Query key prefix; coverage signature is appended automatically. */
+    getGraphKey: () => readonly unknown[];
+    /** Latest merged Overpass session graph (grows incrementally). */
+    useCoverageGraph: () => ParsedOsmData;
+};
+/**
+ * TanStack Query API that rebuilds the route-snapper graph whenever the
+ * Overpass coverage graph grows. Full rebuild (WASM has no incremental API).
+ */
+export declare function createRouteSnapperGraphApi({ getGraphKey, useCoverageGraph, }: CreateRouteSnapperGraphApiOptions): {
+    emptyData: typeof emptyRouteSnapperGraphData;
+    createUseQuery: () => () => import("@tanstack/react-query").UseQueryResult<NoInfer<RouteSnapperGraphData>, Error>;
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { buildRouteSnapperGraphBytes } from './build-graph';
+export { createRouteSnapperGraphApi, emptyRouteSnapperGraphData, type CreateRouteSnapperGraphApiOptions, type RouteSnapperGraphData, } from './create-route-snapper-graph-api';
+export { parsedOsmToXml } from './parsed-osm-to-xml';
+export { countRoutingNetworkEdges, emptyLineCollection, routingNetworkGeoJsonFromBytes, } from './routing-network-geojson';
+export { countRoadWays, coverageGraphSignature, parsedOsmWaysToFeatureCollection, } from './ways-geojson';

package/dist/index.js

@@ -0,0 +1,215 @@
+import initOsmToRouteSnapper, { convert } from '../vendor/osm-to-route-snapper/osm_to_route_snapper.js';
+import { useQuery } from '@tanstack/react-query';
+import initRouteSnapper, { JsRouteSnapper } from 'route-snapper';
+
+// src/parsed-osm-to-xml.ts
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function renderTags(tags) {
+  return Object.entries(tags).map(([key, value]) => `<tag k="${escapeXml(key)}" v="${escapeXml(value)}"/>`).join("");
+}
+function renderNode(node) {
+  return `<node id="${node.id}" lat="${node.lat}" lon="${node.lon}" version="${node.version}" changeset="${node.changeset}"/>`;
+}
+function renderWay(way) {
+  const nds = way.nodes.map((nodeId) => `<nd ref="${nodeId}"/>`).join("");
+  return `<way id="${way.id}" version="${way.version}" changeset="${way.changeset}">${nds}${renderTags(way.tags)}</way>`;
+}
+function parsedOsmToXml(data) {
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const way of Object.values(data.ways)) {
+    for (const nodeId of way.nodes) {
+      nodeIds.add(nodeId);
+    }
+  }
+  const nodes = [...nodeIds].map((nodeId) => {
+    const node = data.nodes[nodeId];
+    if (node) return renderNode(node);
+    const coords = data.nodeCoords[nodeId];
+    if (!coords) return null;
+    return `<node id="${nodeId}" lat="${coords[0]}" lon="${coords[1]}" version="1" changeset="0"/>`;
+  }).filter((line) => line != null).join("");
+  const ways = Object.values(data.ways).map(renderWay).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><osm version="0.6" generator="osm-route-snapper">${nodes}${ways}</osm>`;
+}
+var initPromise;
+async function ensureOsmToRouteSnapperReady() {
+  if (!initPromise) {
+    initPromise = initOsmToRouteSnapper().then(() => void 0);
+  }
+  await initPromise;
+}
+function coverageBoundaryGeoJson(data) {
+  let west = Infinity;
+  let south = Infinity;
+  let east = -Infinity;
+  let north = -Infinity;
+  for (const coords of Object.values(data.nodeCoords)) {
+    const [lat, lon] = coords;
+    west = Math.min(west, lon);
+    east = Math.max(east, lon);
+    south = Math.min(south, lat);
+    north = Math.max(north, lat);
+  }
+  if (!Number.isFinite(west)) {
+    west = 13.2;
+    east = 13.6;
+    south = 52.4;
+    north = 52.6;
+  }
+  const pad = 2e-3;
+  west -= pad;
+  east += pad;
+  south -= pad;
+  north += pad;
+  return JSON.stringify({
+    type: "Polygon",
+    coordinates: [
+      [
+        [west, south],
+        [east, south],
+        [east, north],
+        [west, north],
+        [west, south]
+      ]
+    ]
+  });
+}
+async function buildRouteSnapperGraphBytes(data) {
+  const wayCount = Object.keys(data.ways).length;
+  if (wayCount === 0) return null;
+  await ensureOsmToRouteSnapperReady();
+  const xml = parsedOsmToXml(data);
+  const input = new TextEncoder().encode(xml);
+  return convert(input, coverageBoundaryGeoJson(data));
+}
+var routeSnapperInitPromise;
+async function ensureRouteSnapperReady() {
+  if (!routeSnapperInitPromise) {
+    routeSnapperInitPromise = initRouteSnapper().then(() => void 0);
+  }
+  await routeSnapperInitPromise;
+}
+function emptyLineCollection() {
+  return { type: "FeatureCollection", features: [] };
+}
+async function routingNetworkGeoJsonFromBytes(graphBytes) {
+  await ensureRouteSnapperReady();
+  const snapper = new JsRouteSnapper(graphBytes);
+  try {
+    const parsed = JSON.parse(snapper.debugRenderGraph());
+    const features = parsed.features.filter(
+      (feature) => feature.geometry?.type === "LineString"
+    );
+    return { type: "FeatureCollection", features };
+  } finally {
+    snapper.free();
+  }
+}
+function countRoutingNetworkEdges(collection) {
+  return collection.features.length;
+}
+
+// src/ways-geojson.ts
+function wayLineString(wayId, nodeIds, nodeCoords) {
+  const coordinates = [];
+  for (const nodeId of nodeIds) {
+    const coords = nodeCoords[nodeId];
+    if (!coords) continue;
+    coordinates.push([coords[1], coords[0]]);
+  }
+  if (coordinates.length < 2) return null;
+  return {
+    type: "Feature",
+    properties: { osm_way_id: wayId },
+    geometry: { type: "LineString", coordinates }
+  };
+}
+function parsedOsmWaysToFeatureCollection(data) {
+  const features = [];
+  for (const way of Object.values(data.ways)) {
+    const feature = wayLineString(way.id, way.nodes, data.nodeCoords);
+    if (feature) features.push(feature);
+  }
+  return { type: "FeatureCollection", features };
+}
+function countRoadWays(data) {
+  return Object.keys(data.ways).length;
+}
+function coverageGraphSignature(data) {
+  return [
+    Object.keys(data.ways).length,
+    Object.keys(data.nodes).length,
+    Object.keys(data.nodeCoords).length
+  ].join(":");
+}
+
+// src/create-route-snapper-graph-api.ts
+function emptyRouteSnapperGraphData() {
+  return {
+    graphBytes: null,
+    wayCount: 0,
+    edgeCount: 0,
+    overpassWays: emptyLineCollection(),
+    routingNetwork: emptyLineCollection(),
+    lastError: null
+  };
+}
+function createRouteSnapperGraphApi({
+  getGraphKey,
+  useCoverageGraph
+}) {
+  function createUseQuery() {
+    return function useRouteSnapperGraphQuery() {
+      const graph = useCoverageGraph();
+      const signature = coverageGraphSignature(graph);
+      return useQuery({
+        queryKey: [...getGraphKey(), signature],
+        queryFn: async () => {
+          const wayCount = countRoadWays(graph);
+          if (wayCount === 0) return emptyRouteSnapperGraphData();
+          const overpassWays = parsedOsmWaysToFeatureCollection(graph);
+          try {
+            const graphBytes = await buildRouteSnapperGraphBytes(graph);
+            if (!graphBytes) {
+              return {
+                ...emptyRouteSnapperGraphData(),
+                wayCount,
+                overpassWays
+              };
+            }
+            const routingNetwork = await routingNetworkGeoJsonFromBytes(graphBytes);
+            return {
+              graphBytes,
+              wayCount,
+              edgeCount: countRoutingNetworkEdges(routingNetwork),
+              overpassWays,
+              routingNetwork,
+              lastError: null
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "Graph build failed";
+            console.error("route-snapper graph build failed", error);
+            return {
+              graphBytes: null,
+              wayCount,
+              edgeCount: 0,
+              overpassWays,
+              routingNetwork: emptyLineCollection(),
+              lastError: message
+            };
+          }
+        },
+        staleTime: Number.POSITIVE_INFINITY,
+        enabled: countRoadWays(graph) > 0
+      });
+    };
+  }
+  return {
+    emptyData: emptyRouteSnapperGraphData,
+    createUseQuery
+  };
+}
+
+export { buildRouteSnapperGraphBytes, countRoadWays, countRoutingNetworkEdges, coverageGraphSignature, createRouteSnapperGraphApi, emptyLineCollection, emptyRouteSnapperGraphData, parsedOsmToXml, parsedOsmWaysToFeatureCollection, routingNetworkGeoJsonFromBytes };

package/dist/parsed-osm-to-xml.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedOsmData } from '@osm-editor-kit/osm-data';
+/** Minimal OSM XML for osm-to-route-snapper (highway ways + referenced nodes). */
+export declare function parsedOsmToXml(data: ParsedOsmData): string;

package/dist/routing-network-geojson.d.ts

@@ -0,0 +1,6 @@
+import type { FeatureCollection, LineString } from 'geojson';
+declare function emptyLineCollection(): FeatureCollection<LineString>;
+/** LineStrings for edges in the Rust/WASM route-snapper graph (split at intersections). */
+export declare function routingNetworkGeoJsonFromBytes(graphBytes: Uint8Array): Promise<FeatureCollection<LineString>>;
+export declare function countRoutingNetworkEdges(collection: FeatureCollection<LineString>): number;
+export { emptyLineCollection };

package/dist/ways-geojson.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedOsmData } from '@osm-editor-kit/osm-data';
+import type { FeatureCollection, LineString } from 'geojson';
+/** GeoJSON LineStrings for ways in the Overpass / session OSM cache. */
+export declare function parsedOsmWaysToFeatureCollection(data: ParsedOsmData): FeatureCollection<LineString>;
+export declare function countRoadWays(data: ParsedOsmData): number;
+/** Stable signature so graph queries rebuild when coverage grows. */
+export declare function coverageGraphSignature(data: ParsedOsmData): string;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@osm-editor-kit/osm-route-snapper",
+  "version": "0.1.0-alpha.0",
+  "description": "Build route-snapper graph bytes and routing-network GeoJSON from parsed OSM coverage (WASM).",
+  "license": "MIT",
+  "author": "Tobias Jordans",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/osmberlin/street-space-editor.git",
+    "directory": "packages/osm-route-snapper"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "vendor"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "scripts": {
+    "build": "tsup && rm -f .tsbuildinfo && tsc -p tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "test-run": "bun test src/test",
+    "prepublishOnly": "bun run build && bun ../../scripts/package-exports-for-publish.ts",
+    "postpublish": "bun ../../scripts/package-exports-restore.ts",
+    "prepack": "bun ../../scripts/package-exports-for-publish.ts",
+    "postpack": "bun ../../scripts/package-exports-restore.ts"
+  },
+  "dependencies": {
+    "@osm-editor-kit/osm-data": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/geojson": "^7946.0.16",
+    "@types/react": "^19.1.10",
+    "bun-types": "^1.2.20",
+    "react": "^19.1.1",
+    "route-snapper": "0.4.9",
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.0"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.85.5",
+    "react": "^19.0.0",
+    "route-snapper": "^0.4.9"
+  },
+  "publishExports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/vendor/osm-to-route-snapper/osm_to_route_snapper.d.ts

@@ -0,0 +1,42 @@
+/* tslint:disable */
+/* eslint-disable */
+export function convert(input_bytes: Uint8Array, boundary_geojson: string): Uint8Array
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory
+  readonly convert: (a: number, b: number, c: number, d: number) => [number, number, number, number]
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void
+  readonly __wbindgen_malloc: (a: number, b: number) => number
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number
+  readonly __wbindgen_export_3: WebAssembly.Table
+  readonly __externref_table_dealloc: (a: number) => void
+  readonly __wbindgen_start: () => void
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init(
+  module_or_path?:
+    | { module_or_path: InitInput | Promise<InitInput> }
+    | InitInput
+    | Promise<InitInput>,
+): Promise<InitOutput>

package/vendor/osm-to-route-snapper/osm_to_route_snapper.js

@@ -0,0 +1,305 @@
+let wasm
+
+const cachedTextDecoder =
+  typeof TextDecoder !== 'undefined'
+    ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true })
+    : {
+        decode: () => {
+          throw Error('TextDecoder not available')
+        },
+      }
+
+if (typeof TextDecoder !== 'undefined') {
+  cachedTextDecoder.decode()
+}
+
+let cachedUint8ArrayMemory0 = null
+
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer)
+  }
+  return cachedUint8ArrayMemory0
+}
+
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len))
+}
+
+let WASM_VECTOR_LEN = 0
+
+const cachedTextEncoder =
+  typeof TextEncoder !== 'undefined'
+    ? new TextEncoder('utf-8')
+    : {
+        encode: () => {
+          throw Error('TextEncoder not available')
+        },
+      }
+
+const encodeString =
+  typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+        return cachedTextEncoder.encodeInto(arg, view)
+      }
+    : function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg)
+        view.set(buf)
+        return {
+          read: arg.length,
+          written: buf.length,
+        }
+      }
+
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = cachedTextEncoder.encode(arg)
+    const ptr = malloc(buf.length, 1) >>> 0
+    getUint8ArrayMemory0()
+      .subarray(ptr, ptr + buf.length)
+      .set(buf)
+    WASM_VECTOR_LEN = buf.length
+    return ptr
+  }
+
+  let len = arg.length
+  let ptr = malloc(len, 1) >>> 0
+
+  const mem = getUint8ArrayMemory0()
+
+  let offset = 0
+
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset)
+    if (code > 0x7f) break
+    mem[ptr + offset] = code
+  }
+
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset)
+    }
+    ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len)
+    const ret = encodeString(arg, view)
+
+    offset += ret.written
+    ptr = realloc(ptr, len, offset, 1) >>> 0
+  }
+
+  WASM_VECTOR_LEN = offset
+  return ptr
+}
+
+let cachedDataViewMemory0 = null
+
+function getDataViewMemory0() {
+  if (
+    cachedDataViewMemory0 === null ||
+    cachedDataViewMemory0.buffer.detached === true ||
+    (cachedDataViewMemory0.buffer.detached === undefined &&
+      cachedDataViewMemory0.buffer !== wasm.memory.buffer)
+  ) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer)
+  }
+  return cachedDataViewMemory0
+}
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0
+  getUint8ArrayMemory0().set(arg, ptr / 1)
+  WASM_VECTOR_LEN = arg.length
+  return ptr
+}
+
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_3.get(idx)
+  wasm.__externref_table_dealloc(idx)
+  return value
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len)
+}
+/**
+ * @param {Uint8Array} input_bytes
+ * @param {string} boundary_geojson
+ * @returns {Uint8Array}
+ */
+export function convert(input_bytes, boundary_geojson) {
+  const ptr0 = passArray8ToWasm0(input_bytes, wasm.__wbindgen_malloc)
+  const len0 = WASM_VECTOR_LEN
+  const ptr1 = passStringToWasm0(boundary_geojson, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
+  const len1 = WASM_VECTOR_LEN
+  const ret = wasm.convert(ptr0, len0, ptr1, len1)
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2])
+  }
+  var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice()
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1)
+  return v3
+}
+
+async function __wbg_load(module, imports) {
+  if (typeof Response === 'function' && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === 'function') {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports)
+      } catch (e) {
+        if (module.headers.get('Content-Type') != 'application/wasm') {
+          console.warn(
+            '`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n',
+            e,
+          )
+        } else {
+          throw e
+        }
+      }
+    }
+
+    const bytes = await module.arrayBuffer()
+    return await WebAssembly.instantiate(bytes, imports)
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports)
+
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module }
+    } else {
+      return instance
+    }
+  }
+}
+
+function __wbg_get_imports() {
+  const imports = {}
+  imports.wbg = {}
+  imports.wbg.__wbg_debug_dd7b0d8e36e37544 = function (arg0) {
+    console.debug(arg0)
+  }
+  imports.wbg.__wbg_error_0aa52a01e6e7818f = function (arg0) {
+    console.error(arg0)
+  }
+  imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function (arg0, arg1) {
+    let deferred0_0
+    let deferred0_1
+    try {
+      deferred0_0 = arg0
+      deferred0_1 = arg1
+      console.error(getStringFromWasm0(arg0, arg1))
+    } finally {
+      wasm.__wbindgen_free(deferred0_0, deferred0_1, 1)
+    }
+  }
+  imports.wbg.__wbg_info_82e75a55937c8734 = function (arg0) {
+    console.info(arg0)
+  }
+  imports.wbg.__wbg_log_42eff0132cf97143 = function (arg0) {
+    console.log(arg0)
+  }
+  imports.wbg.__wbg_new_8a6f238a6ece86ea = function () {
+    const ret = new Error()
+    return ret
+  }
+  imports.wbg.__wbg_stack_0ed75d68575b0f3c = function (arg0, arg1) {
+    const ret = arg1.stack
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
+    const len1 = WASM_VECTOR_LEN
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true)
+    getDataViewMemory0().setInt32(arg0 + 0, ptr1, true)
+  }
+  imports.wbg.__wbg_warn_daee763c4ce7051e = function (arg0) {
+    console.warn(arg0)
+  }
+  imports.wbg.__wbindgen_init_externref_table = function () {
+    const table = wasm.__wbindgen_export_3
+    const offset = table.grow(4)
+    table.set(0, undefined)
+    table.set(offset + 0, undefined)
+    table.set(offset + 1, null)
+    table.set(offset + 2, true)
+    table.set(offset + 3, false)
+  }
+  imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1)
+    return ret
+  }
+  imports.wbg.__wbindgen_throw = function (arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1))
+  }
+
+  return imports
+}
+
+function __wbg_init_memory(_imports, _memory) {}
+
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports
+  __wbg_init.__wbindgen_wasm_module = module
+  cachedDataViewMemory0 = null
+  cachedUint8ArrayMemory0 = null
+
+  wasm.__wbindgen_start()
+  return wasm
+}
+
+function initSync(module) {
+  if (wasm !== undefined) return wasm
+
+  if (typeof module !== 'undefined') {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ;({ module } = module)
+    } else {
+      console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+    }
+  }
+
+  const imports = __wbg_get_imports()
+
+  __wbg_init_memory(imports)
+
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module)
+  }
+
+  const instance = new WebAssembly.Instance(module, imports)
+
+  return __wbg_finalize_init(instance, module)
+}
+
+async function __wbg_init(module_or_path) {
+  if (wasm !== undefined) return wasm
+
+  if (typeof module_or_path !== 'undefined') {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ;({ module_or_path } = module_or_path)
+    } else {
+      console.warn(
+        'using deprecated parameters for the initialization function; pass a single object instead',
+      )
+    }
+  }
+
+  if (typeof module_or_path === 'undefined') {
+    module_or_path = new URL('osm_to_route_snapper_bg.wasm', import.meta.url)
+  }
+  const imports = __wbg_get_imports()
+
+  if (
+    typeof module_or_path === 'string' ||
+    (typeof Request === 'function' && module_or_path instanceof Request) ||
+    (typeof URL === 'function' && module_or_path instanceof URL)
+  ) {
+    module_or_path = fetch(module_or_path)
+  }
+
+  __wbg_init_memory(imports)
+
+  const { instance, module } = await __wbg_load(await module_or_path, imports)
+
+  return __wbg_finalize_init(instance, module)
+}
+
+export { initSync }
+export default __wbg_init