roadgraph-router-v2 0.1.0 → 0.3.0

package/dist/chunk-4FIOQAFG.js

@@ -1,1333 +0,0 @@
-// src/varint.ts
-function zigzag(value) {
-  return (value << 1 ^ value >> 31) >>> 0;
-}
-function unzigzag(value) {
-  return value >>> 1 ^ -(value & 1);
-}
-var VarintWriter = class {
-  bytes;
-  length = 0;
-  constructor(capacity = 1024) {
-    this.bytes = new Uint8Array(capacity);
-  }
-  reserve(extra) {
-    if (this.length + extra <= this.bytes.length) return;
-    let capacity = this.bytes.length * 2;
-    while (capacity < this.length + extra) capacity *= 2;
-    const grown = new Uint8Array(capacity);
-    grown.set(this.bytes.subarray(0, this.length));
-    this.bytes = grown;
-  }
-  /** Appends an unsigned integer. Values must be below 2^32. */
-  push(value) {
-    this.reserve(5);
-    let remaining = value >>> 0;
-    while (remaining > 127) {
-      this.bytes[this.length++] = remaining & 127 | 128;
-      remaining >>>= 7;
-    }
-    this.bytes[this.length++] = remaining;
-  }
-  /** Appends a signed integer through zigzag, so small magnitudes stay short. */
-  pushSigned(value) {
-    this.push(zigzag(value));
-  }
-  get byteLength() {
-    return this.length;
-  }
-  toUint8Array() {
-    return this.bytes.subarray(0, this.length);
-  }
-};
-var VarintReader = class {
-  constructor(bytes, start = 0) {
-    this.bytes = bytes;
-    this.at = start;
-  }
-  bytes;
-  at;
-  read() {
-    let value = 0;
-    let shift = 0;
-    for (; ; ) {
-      const byte = this.bytes[this.at++];
-      value += shift < 28 ? (byte & 127) << shift : (byte & 127) * 2 ** shift;
-      if ((byte & 128) === 0) return value >>> 0;
-      shift += 7;
-      if (shift > 35) throw new Error("Malformed varint in routing graph.");
-    }
-  }
-  readSigned() {
-    return unzigzag(this.read());
-  }
-  get offset() {
-    return this.at;
-  }
-};
-
-// src/codec.ts
-var MAGIC = 1162236500;
-var VERSION = 1;
-var HEADER_BYTES = 16;
-var COMPACT_MAGIC = 844252741;
-var COMPACT_VERSION = 2;
-var SHAPED_COMPACT_VERSION = 3;
-var RESTRICTED_COMPACT_VERSION = 4;
-var SEQUENCED_COMPACT_VERSION = 5;
-var COMPACT_HEADER_BYTES = 32;
-var SHAPED_COMPACT_HEADER_BYTES = 40;
-var SUPPORTED_COMPACT_VERSIONS = /* @__PURE__ */ new Set([COMPACT_VERSION, SHAPED_COMPACT_VERSION, RESTRICTED_COMPACT_VERSION, SEQUENCED_COMPACT_VERSION, 6]);
-function encodeGraph(graph) {
-  const nodes = graph.nodeLatitudes.length, edges = graph.edgeTargets.length;
-  if (graph.nodeLongitudes.length !== nodes || graph.edgeOffsets.length !== nodes + 1 || graph.edgeDistancesMeters.length !== edges || graph.edgeDurationsSeconds.length !== edges || graph.edgeOffsets[nodes] !== edges) throw new Error("Invalid road graph");
-  const buffer = new ArrayBuffer(HEADER_BYTES + nodes * 16 + (nodes + 1) * 4 + edges * 12);
-  const view = new DataView(buffer);
-  view.setUint32(0, MAGIC, true);
-  view.setUint16(4, VERSION, true);
-  view.setUint32(8, nodes, true);
-  view.setUint32(12, edges, true);
-  const coordinateScale = graph.coordinateScale ?? 1;
-  const distanceScale = graph.edgeDistanceScale ?? 1;
-  const durationScale = graph.edgeDurationScale ?? 1;
-  let offset = HEADER_BYTES;
-  new Float64Array(buffer, offset, nodes).set(Float64Array.from(graph.nodeLatitudes, (value) => value / coordinateScale));
-  offset += nodes * 8;
-  new Float64Array(buffer, offset, nodes).set(Float64Array.from(graph.nodeLongitudes, (value) => value / coordinateScale));
-  offset += nodes * 8;
-  new Uint32Array(buffer, offset, nodes + 1).set(graph.edgeOffsets);
-  offset += (nodes + 1) * 4;
-  new Uint32Array(buffer, offset, edges).set(graph.edgeTargets);
-  offset += edges * 4;
-  new Float32Array(buffer, offset, edges).set(Float32Array.from(graph.edgeDistancesMeters, (value) => value * distanceScale));
-  offset += edges * 4;
-  new Float32Array(buffer, offset, edges).set(Float32Array.from(graph.edgeDurationsSeconds, (value) => value * durationScale));
-  return buffer;
-}
-function decodeGraph(buffer) {
-  if (buffer.byteLength < HEADER_BYTES) throw new Error("Invalid routing graph header");
-  const view = new DataView(buffer), magic = view.getUint32(0, true), version = view.getUint16(4, true);
-  if (magic === COMPACT_MAGIC && SUPPORTED_COMPACT_VERSIONS.has(version)) return decodeCompactGraph(buffer);
-  if (magic !== MAGIC || version !== VERSION) throw new Error("Unsupported routing graph format");
-  const nodes = view.getUint32(8, true), edges = view.getUint32(12, true), expected = HEADER_BYTES + nodes * 16 + (nodes + 1) * 4 + edges * 12;
-  if (buffer.byteLength !== expected) throw new Error("Truncated routing graph");
-  let offset = HEADER_BYTES;
-  const nodeLatitudes = new Float64Array(buffer.slice(offset, offset += nodes * 8));
-  const nodeLongitudes = new Float64Array(buffer.slice(offset, offset += nodes * 8));
-  const edgeOffsets = new Uint32Array(buffer.slice(offset, offset += (nodes + 1) * 4));
-  const edgeTargets = new Uint32Array(buffer.slice(offset, offset += edges * 4));
-  const edgeDistancesMeters = new Float32Array(buffer.slice(offset, offset += edges * 4));
-  const edgeDurationsSeconds = new Float32Array(buffer.slice(offset, offset += edges * 4));
-  assertGeographic(nodeLatitudes, nodeLongitudes, 1);
-  for (const target of edgeTargets) if (target >= nodes) throw new Error("Invalid routing graph: edge target outside the graph.");
-  assertOffsets(edgeOffsets, nodes, edges, "edge offsets");
-  return { nodeLatitudes, nodeLongitudes, edgeOffsets, edgeTargets, edgeDistancesMeters, edgeDurationsSeconds };
-}
-function encodeCompactGraph(graph, options = {}) {
-  return (options.layout ?? "packed") === "packed" ? encodePackedGraph(graph) : encodeLegacyCompactGraph(graph);
-}
-function encodeLegacyCompactGraph(graph) {
-  if (!(graph.nodeLatitudes instanceof Int32Array) || !(graph.nodeLongitudes instanceof Int32Array) || !(graph.edgeDistancesMeters instanceof Uint16Array) || !(graph.edgeDurationsSeconds instanceof Uint16Array)) throw new Error("Compact graphs require Int32 coordinates and Uint16 edge weights.");
-  const coordinateScale = graph.coordinateScale ?? 0, edgeDistanceScale = graph.edgeDistanceScale ?? 1, edgeDurationScale = graph.edgeDurationScale ?? 1;
-  if (!Number.isInteger(coordinateScale) || !Number.isInteger(edgeDistanceScale) || !Number.isInteger(edgeDurationScale) || coordinateScale <= 0 || edgeDistanceScale <= 0 || edgeDurationScale <= 0 || edgeDistanceScale > 65535 || edgeDurationScale > 65535) throw new Error("Invalid compact graph scales.");
-  const nodes = graph.nodeLatitudes.length, edges = graph.edgeTargets.length;
-  if (graph.nodeLongitudes.length !== nodes || graph.edgeOffsets.length !== nodes + 1 || graph.edgeDistancesMeters.length !== edges || graph.edgeDurationsSeconds.length !== edges || graph.edgeOffsets[nodes] !== edges) throw new Error("Invalid road graph");
-  const sequenceEdges = graph.turnRestrictionSequenceEdges?.length ?? 0;
-  const sequences = sequenceEdges ? (graph.turnRestrictionSequenceOffsets?.length ?? 1) - 1 : 0;
-  if (sequences && (!graph.turnRestrictionSequenceOffsets || graph.turnRestrictionSequenceOffsets[sequences] !== sequenceEdges)) throw new Error("Invalid compact turn restriction sequences.");
-  for (let index = 0; index < sequenceEdges; index += 1) if (graph.turnRestrictionSequenceEdges[index] >= edges) throw new Error("Turn restriction references an edge outside the graph.");
-  const restricted = Boolean(graph.turnRestrictionFromEdges?.length || graph.turnRestrictionToEdges?.length) || sequences > 0;
-  if ((graph.turnRestrictionFromEdges?.length ?? 0) !== (graph.turnRestrictionToEdges?.length ?? 0)) throw new Error("Invalid compact turn restrictions.");
-  const restrictions = graph.turnRestrictionFromEdges?.length ?? 0;
-  for (let pair = 0; pair < restrictions; pair += 1) if (graph.turnRestrictionFromEdges[pair] >= edges || graph.turnRestrictionToEdges[pair] >= edges) throw new Error("Turn restriction references an edge outside the graph.");
-  const hasShapes = Boolean(graph.edgeShapeOffsets || graph.edgeShapeLatitudes || graph.edgeShapeLongitudes);
-  if (hasShapes && (!graph.edgeShapeOffsets || !graph.edgeShapeLatitudes || !graph.edgeShapeLongitudes || graph.edgeShapeOffsets.length !== edges + 1 || graph.edgeShapeLatitudes.length !== graph.edgeShapeLongitudes.length || graph.edgeShapeOffsets[edges] !== graph.edgeShapeLatitudes.length)) throw new Error("Invalid compact edge geometry.");
-  const shaped = hasShapes || restricted;
-  const version = sequences ? SEQUENCED_COMPACT_VERSION : restricted ? RESTRICTED_COMPACT_VERSION : hasShapes ? SHAPED_COMPACT_VERSION : COMPACT_VERSION;
-  const points = graph.edgeShapeLatitudes?.length ?? 0, header = shaped ? SHAPED_COMPACT_HEADER_BYTES : COMPACT_HEADER_BYTES;
-  const buffer = new ArrayBuffer(header + nodes * 8 + (nodes + 1) * 4 + edges * 8 + (shaped ? (edges + 1) * 4 + points * 8 : 0) + restrictions * 8 + (sequences ? (sequences + 1) * 4 + sequenceEdges * 4 : 0));
-  const view = new DataView(buffer);
-  view.setUint32(0, COMPACT_MAGIC, true);
-  view.setUint16(4, version, true);
-  view.setUint32(8, nodes, true);
-  view.setUint32(12, edges, true);
-  view.setUint32(16, coordinateScale, true);
-  view.setUint16(20, edgeDistanceScale, true);
-  view.setUint16(22, edgeDurationScale, true);
-  if (shaped) {
-    view.setUint32(24, points, true);
-    view.setUint32(28, restrictions, true);
-    view.setUint32(32, sequences, true);
-    view.setUint32(36, sequenceEdges, true);
-  }
-  let offset = header;
-  new Int32Array(buffer, offset, nodes).set(graph.nodeLatitudes);
-  offset += nodes * 4;
-  new Int32Array(buffer, offset, nodes).set(graph.nodeLongitudes);
-  offset += nodes * 4;
-  new Uint32Array(buffer, offset, nodes + 1).set(graph.edgeOffsets);
-  offset += (nodes + 1) * 4;
-  new Uint32Array(buffer, offset, edges).set(graph.edgeTargets);
-  offset += edges * 4;
-  new Uint16Array(buffer, offset, edges).set(graph.edgeDistancesMeters);
-  offset += edges * 2;
-  new Uint16Array(buffer, offset, edges).set(graph.edgeDurationsSeconds);
-  offset += edges * 2;
-  if (shaped) {
-    if (hasShapes) new Uint32Array(buffer, offset, edges + 1).set(graph.edgeShapeOffsets);
-    offset += (edges + 1) * 4;
-    new Int32Array(buffer, offset, points).set(graph.edgeShapeLatitudes ?? []);
-    offset += points * 4;
-    new Int32Array(buffer, offset, points).set(graph.edgeShapeLongitudes ?? []);
-    offset += points * 4;
-  }
-  if (restrictions) {
-    new Uint32Array(buffer, offset, restrictions).set(graph.turnRestrictionFromEdges);
-    offset += restrictions * 4;
-    new Uint32Array(buffer, offset, restrictions).set(graph.turnRestrictionToEdges);
-    offset += restrictions * 4;
-  }
-  if (sequences) {
-    new Uint32Array(buffer, offset, sequences + 1).set(graph.turnRestrictionSequenceOffsets);
-    offset += (sequences + 1) * 4;
-    new Uint32Array(buffer, offset, sequenceEdges).set(graph.turnRestrictionSequenceEdges);
-  }
-  return buffer;
-}
-function decodeCompactGraph(buffer) {
-  if (buffer.byteLength < COMPACT_HEADER_BYTES) throw new Error("Invalid compact routing graph header");
-  const view = new DataView(buffer), version = view.getUint16(4, true), nodes = view.getUint32(8, true), edges = view.getUint32(12, true), coordinateScale = view.getUint32(16, true), edgeDistanceScale = view.getUint16(20, true), edgeDurationScale = view.getUint16(22, true);
-  if (version === 6) return decodePackedGraph(buffer);
-  const shaped = version >= SHAPED_COMPACT_VERSION, points = shaped ? view.getUint32(24, true) : 0, header = shaped ? SHAPED_COMPACT_HEADER_BYTES : COMPACT_HEADER_BYTES;
-  const restrictions = version >= RESTRICTED_COMPACT_VERSION ? view.getUint32(28, true) : 0;
-  const sequences = version >= SEQUENCED_COMPACT_VERSION ? view.getUint32(32, true) : 0;
-  const sequenceEdges = version >= SEQUENCED_COMPACT_VERSION ? view.getUint32(36, true) : 0;
-  const expected = header + nodes * 8 + (nodes + 1) * 4 + edges * 8 + (shaped ? (edges + 1) * 4 + points * 8 : 0) + restrictions * 8 + (sequences ? (sequences + 1) * 4 + sequenceEdges * 4 : 0);
-  if (!coordinateScale || !edgeDistanceScale || !edgeDurationScale || buffer.byteLength !== expected) throw new Error("Truncated compact routing graph");
-  let offset = header;
-  const nodeLatitudes = new Int32Array(buffer.slice(offset, offset += nodes * 4));
-  const nodeLongitudes = new Int32Array(buffer.slice(offset, offset += nodes * 4));
-  const edgeOffsets = new Uint32Array(buffer.slice(offset, offset += (nodes + 1) * 4));
-  const edgeTargets = new Uint32Array(buffer.slice(offset, offset += edges * 4));
-  const edgeDistancesMeters = new Uint16Array(buffer.slice(offset, offset += edges * 2));
-  const edgeDurationsSeconds = new Uint16Array(buffer.slice(offset, offset += edges * 2));
-  assertGeographic(nodeLatitudes, nodeLongitudes, coordinateScale);
-  for (const target of edgeTargets) if (target >= nodes) throw new Error("Invalid routing graph: edge target outside the graph.");
-  assertOffsets(edgeOffsets, nodes, edges, "edge offsets");
-  const graph = { nodeLatitudes, nodeLongitudes, edgeOffsets, edgeTargets, edgeDistancesMeters, edgeDurationsSeconds, coordinateScale, edgeDistanceScale, edgeDurationScale };
-  if (!shaped) return graph;
-  const edgeShapeOffsets = new Uint32Array(buffer.slice(offset, offset += (edges + 1) * 4));
-  const edgeShapeLatitudes = new Int32Array(buffer.slice(offset, offset += points * 4));
-  const edgeShapeLongitudes = new Int32Array(buffer.slice(offset, offset += points * 4));
-  if (points) {
-    assertOffsets(edgeShapeOffsets, edges, points, "shape offsets");
-    assertGeographic(edgeShapeLatitudes, edgeShapeLongitudes, coordinateScale);
-    Object.assign(graph, { edgeShapeOffsets, edgeShapeLatitudes, edgeShapeLongitudes });
-  }
-  if (restrictions) {
-    graph.turnRestrictionFromEdges = new Uint32Array(buffer.slice(offset, offset += restrictions * 4));
-    graph.turnRestrictionToEdges = new Uint32Array(buffer.slice(offset, offset += restrictions * 4));
-  }
-  if (sequences) {
-    graph.turnRestrictionSequenceOffsets = new Uint32Array(buffer.slice(offset, offset += (sequences + 1) * 4));
-    graph.turnRestrictionSequenceEdges = new Uint32Array(buffer.slice(offset, offset += sequenceEdges * 4));
-    assertOffsets(graph.turnRestrictionSequenceOffsets, sequences, sequenceEdges, "turn restriction offsets");
-  }
-  for (const edge of [...graph.turnRestrictionFromEdges ?? [], ...graph.turnRestrictionToEdges ?? [], ...graph.turnRestrictionSequenceEdges ?? []]) {
-    if (edge >= edges) throw new Error("Invalid routing graph: turn restriction references an edge outside the graph.");
-  }
-  return graph;
-}
-var PACKED_COMPACT_VERSION = 6;
-var PACKED_HEADER_BYTES = 64;
-function alignUp(offset) {
-  return offset + 3 & ~3;
-}
-function assertOffsets(offsets, entries, total, what) {
-  if (offsets.length !== entries + 1 || offsets[0] !== 0 || offsets[entries] !== total) throw new Error(`Invalid routing graph: ${what} do not span the data.`);
-  for (let index = 1; index <= entries; index += 1) {
-    if (offsets[index] < offsets[index - 1] || offsets[index] > total) throw new Error(`Invalid routing graph: ${what} are not ordered.`);
-  }
-}
-function assertGeographic(latitudes, longitudes, scale) {
-  for (let index = 0; index < latitudes.length; index += 1) {
-    if (!(Math.abs(latitudes[index] / scale) <= 90) || !(Math.abs(longitudes[index] / scale) <= 180)) {
-      throw new Error("Invalid routing graph: coordinate outside the world.");
-    }
-  }
-}
-function buildShapeTable(graph) {
-  const edges = graph.edgeTargets.length;
-  const offsets = graph.edgeShapeOffsets;
-  const latitudes = graph.edgeShapeLatitudes;
-  const longitudes = graph.edgeShapeLongitudes;
-  const references = new Uint32Array(edges);
-  const shapes = [];
-  if (!offsets || !latitudes || !longitudes) return { references, shapes, latitudes, longitudes };
-  const seen = /* @__PURE__ */ new Map();
-  for (let edge = 0; edge < edges; edge += 1) {
-    const start = offsets[edge];
-    const count = offsets[edge + 1] - start;
-    if (!count) continue;
-    const forward = [];
-    const backward = [];
-    for (let point = 0; point < count; point += 1) {
-      forward.push(latitudes[start + point], longitudes[start + point]);
-      backward.push(latitudes[start + count - 1 - point], longitudes[start + count - 1 - point]);
-    }
-    const forwardKey = forward.join(",");
-    const existing = seen.get(forwardKey);
-    if (existing !== void 0) {
-      references[edge] = (existing + 1) * 2;
-      continue;
-    }
-    const mirrored = seen.get(backward.join(","));
-    if (mirrored !== void 0) {
-      references[edge] = (mirrored + 1) * 2 + 1;
-      continue;
-    }
-    const id = shapes.length;
-    shapes.push({ start, count });
-    seen.set(forwardKey, id);
-    references[edge] = (id + 1) * 2;
-  }
-  return { references, shapes, latitudes, longitudes };
-}
-function encodePackedGraph(graph) {
-  const nodes = graph.nodeLatitudes.length;
-  const edges = graph.edgeTargets.length;
-  if (!(graph.nodeLatitudes instanceof Int32Array) || !(graph.nodeLongitudes instanceof Int32Array) || !(graph.edgeDistancesMeters instanceof Uint16Array) || !(graph.edgeDurationsSeconds instanceof Uint16Array)) throw new Error("Compact graphs require Int32 coordinates and Uint16 edge weights.");
-  if (graph.nodeLongitudes.length !== nodes || graph.edgeOffsets.length !== nodes + 1 || graph.edgeDistancesMeters.length !== edges || graph.edgeDurationsSeconds.length !== edges || graph.edgeOffsets[nodes] !== edges) throw new Error("Invalid road graph");
-  const coordinateScale = graph.coordinateScale ?? 0;
-  if (!Number.isInteger(coordinateScale) || coordinateScale <= 0) throw new Error("Invalid compact graph scales.");
-  if ((graph.turnRestrictionFromEdges?.length ?? 0) !== (graph.turnRestrictionToEdges?.length ?? 0)) throw new Error("Invalid compact turn restrictions.");
-  for (const edge of graph.turnRestrictionFromEdges ?? []) if (edge >= edges) throw new Error("Turn restriction references an edge outside the graph.");
-  for (const edge of graph.turnRestrictionToEdges ?? []) if (edge >= edges) throw new Error("Turn restriction references an edge outside the graph.");
-  for (const edge of graph.turnRestrictionSequenceEdges ?? []) if (edge >= edges) throw new Error("Turn restriction references an edge outside the graph.");
-  const { references, shapes, latitudes, longitudes } = buildShapeTable(graph);
-  const degrees = new VarintWriter(nodes + 16);
-  for (let node = 0; node < nodes; node += 1) degrees.push(graph.edgeOffsets[node + 1] - graph.edgeOffsets[node]);
-  const targets = new VarintWriter(edges + 16);
-  for (let node = 0; node < nodes; node += 1) {
-    for (let edge = graph.edgeOffsets[node]; edge < graph.edgeOffsets[node + 1]; edge += 1) targets.pushSigned(graph.edgeTargets[edge] - node);
-  }
-  const shapeRefs = new VarintWriter(edges + 16);
-  for (let edge = 0; edge < edges; edge += 1) shapeRefs.push(references[edge]);
-  const shapeSizes = new VarintWriter(shapes.length + 16);
-  for (const shape of shapes) shapeSizes.push(shape.count);
-  const shapePoints = new VarintWriter(shapes.length * 8 + 16);
-  for (const shape of shapes) {
-    let previousLat = 0;
-    let previousLng = 0;
-    for (let point = 0; point < shape.count; point += 1) {
-      const lat = latitudes[shape.start + point];
-      const lng = longitudes[shape.start + point];
-      shapePoints.pushSigned(point ? lat - previousLat : lat);
-      shapePoints.pushSigned(point ? lng - previousLng : lng);
-      previousLat = lat;
-      previousLng = lng;
-    }
-  }
-  const pairs = graph.turnRestrictionFromEdges?.length ?? 0;
-  const runs = graph.turnRestrictionSequenceEdges?.length ? (graph.turnRestrictionSequenceOffsets?.length ?? 1) - 1 : 0;
-  const runEdges = graph.turnRestrictionSequenceEdges?.length ?? 0;
-  const sections = [degrees, targets, shapeRefs, shapeSizes, shapePoints];
-  const variableBytes = sections.reduce((sum, section) => sum + section.byteLength, 0);
-  const restrictionsAt = alignUp(PACKED_HEADER_BYTES + nodes * 8 + edges * 4 + variableBytes);
-  const buffer = new ArrayBuffer(restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0));
-  const view = new DataView(buffer);
-  view.setUint32(0, COMPACT_MAGIC, true);
-  view.setUint16(4, PACKED_COMPACT_VERSION, true);
-  view.setUint32(8, nodes, true);
-  view.setUint32(12, edges, true);
-  view.setUint32(16, graph.coordinateScale ?? 0, true);
-  view.setUint16(20, graph.edgeDistanceScale ?? 1, true);
-  view.setUint16(22, graph.edgeDurationScale ?? 1, true);
-  view.setUint32(24, shapes.length, true);
-  view.setUint32(28, pairs, true);
-  view.setUint32(32, runs, true);
-  view.setUint32(36, runEdges, true);
-  for (let index = 0; index < sections.length; index += 1) view.setUint32(40 + index * 4, sections[index].byteLength, true);
-  let offset = PACKED_HEADER_BYTES;
-  new Int32Array(buffer, offset, nodes).set(graph.nodeLatitudes);
-  offset += nodes * 4;
-  new Int32Array(buffer, offset, nodes).set(graph.nodeLongitudes);
-  offset += nodes * 4;
-  new Uint16Array(buffer, offset, edges).set(graph.edgeDistancesMeters);
-  offset += edges * 2;
-  new Uint16Array(buffer, offset, edges).set(graph.edgeDurationsSeconds);
-  offset += edges * 2;
-  const bytes = new Uint8Array(buffer);
-  for (const section of sections) {
-    bytes.set(section.toUint8Array(), offset);
-    offset += section.byteLength;
-  }
-  offset = restrictionsAt;
-  if (pairs) {
-    new Uint32Array(buffer, offset, pairs).set(graph.turnRestrictionFromEdges);
-    offset += pairs * 4;
-    new Uint32Array(buffer, offset, pairs).set(graph.turnRestrictionToEdges);
-    offset += pairs * 4;
-  }
-  if (runs) {
-    new Uint32Array(buffer, offset, runs + 1).set(graph.turnRestrictionSequenceOffsets);
-    offset += (runs + 1) * 4;
-    new Uint32Array(buffer, offset, runEdges).set(graph.turnRestrictionSequenceEdges);
-  }
-  return buffer;
-}
-function decodePackedGraph(buffer) {
-  const view = new DataView(buffer);
-  const nodes = view.getUint32(8, true);
-  const edges = view.getUint32(12, true);
-  const coordinateScale = view.getUint32(16, true);
-  const edgeDistanceScale = view.getUint16(20, true);
-  const edgeDurationScale = view.getUint16(22, true);
-  const shapeCount = view.getUint32(24, true);
-  const pairs = view.getUint32(28, true);
-  const runs = view.getUint32(32, true);
-  const runEdges = view.getUint32(36, true);
-  const lengths = Array.from({ length: 5 }, (_, index) => view.getUint32(40 + index * 4, true));
-  const variableBytes = lengths.reduce((sum, length) => sum + length, 0);
-  const restrictionsAt = alignUp(PACKED_HEADER_BYTES + nodes * 8 + edges * 4 + variableBytes);
-  const expected = restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0);
-  if (!coordinateScale || !edgeDistanceScale || !edgeDurationScale || buffer.byteLength !== expected) throw new Error("Truncated compact routing graph");
-  if (shapeCount > edges) throw new Error("Invalid compact routing graph: more shapes than edges.");
-  let offset = PACKED_HEADER_BYTES;
-  const nodeLatitudes = new Int32Array(buffer.slice(offset, offset += nodes * 4));
-  const nodeLongitudes = new Int32Array(buffer.slice(offset, offset += nodes * 4));
-  const edgeDistancesMeters = new Uint16Array(buffer.slice(offset, offset += edges * 2));
-  const edgeDurationsSeconds = new Uint16Array(buffer.slice(offset, offset += edges * 2));
-  const bytes = new Uint8Array(buffer);
-  const starts = [];
-  for (const length of lengths) {
-    starts.push(offset);
-    offset += length;
-  }
-  offset = restrictionsAt;
-  const edgeOffsets = new Uint32Array(nodes + 1);
-  const degrees = new VarintReader(bytes, starts[0]);
-  for (let node = 0; node < nodes; node += 1) {
-    const degree = degrees.read();
-    if (degree > edges - edgeOffsets[node]) throw new Error("Invalid compact routing graph: node degrees exceed the edge count.");
-    edgeOffsets[node + 1] = edgeOffsets[node] + degree;
-  }
-  if (edgeOffsets[nodes] !== edges) throw new Error("Invalid compact routing graph: node degrees do not sum to the edge count.");
-  const edgeTargets = new Uint32Array(edges);
-  const targets = new VarintReader(bytes, starts[1]);
-  for (let node = 0; node < nodes; node += 1) {
-    for (let edge = edgeOffsets[node]; edge < edgeOffsets[node + 1]; edge += 1) {
-      const target = node + targets.readSigned();
-      if (target < 0 || target >= nodes) throw new Error("Invalid compact routing graph: edge target outside the graph.");
-      edgeTargets[edge] = target;
-    }
-  }
-  assertGeographic(nodeLatitudes, nodeLongitudes, coordinateScale);
-  const graph = { nodeLatitudes, nodeLongitudes, edgeOffsets, edgeTargets, edgeDistancesMeters, edgeDurationsSeconds, coordinateScale, edgeDistanceScale, edgeDurationScale };
-  const references = new Uint32Array(edges);
-  const shapeRefs = new VarintReader(bytes, starts[2]);
-  for (let edge = 0; edge < edges; edge += 1) {
-    references[edge] = shapeRefs.read();
-    if (references[edge] >>> 1 > shapeCount) throw new Error("Invalid compact routing graph: edge references a missing shape.");
-  }
-  const shapeSizes = new VarintReader(bytes, starts[3]);
-  const sizes = new Uint32Array(shapeCount);
-  const pointCeiling = Math.floor(lengths[4] / 2);
-  let totalPoints = 0;
-  for (let shape = 0; shape < shapeCount; shape += 1) {
-    sizes[shape] = shapeSizes.read();
-    totalPoints += sizes[shape];
-    if (totalPoints > pointCeiling) throw new Error("Invalid compact routing graph: shape sizes exceed the stored geometry.");
-  }
-  const tableLatitudes = new Int32Array(totalPoints);
-  const tableLongitudes = new Int32Array(totalPoints);
-  const tableStarts = new Uint32Array(shapeCount + 1);
-  const points = new VarintReader(bytes, starts[4]);
-  let at = 0;
-  for (let shape = 0; shape < shapeCount; shape += 1) {
-    tableStarts[shape] = at;
-    let lat = 0;
-    let lng = 0;
-    for (let point = 0; point < sizes[shape]; point += 1) {
-      lat = point ? lat + points.readSigned() : points.readSigned();
-      lng = point ? lng + points.readSigned() : points.readSigned();
-      tableLatitudes[at] = lat;
-      tableLongitudes[at] = lng;
-      at += 1;
-    }
-  }
-  tableStarts[shapeCount] = at;
-  const edgeShapeOffsets = new Uint32Array(edges + 1);
-  for (let edge = 0; edge < edges; edge += 1) {
-    const reference = references[edge];
-    edgeShapeOffsets[edge + 1] = edgeShapeOffsets[edge] + (reference ? sizes[(reference >>> 1) - 1] : 0);
-  }
-  const expandedPoints = edgeShapeOffsets[edges];
-  if (expandedPoints) {
-    const edgeShapeLatitudes = new Int32Array(expandedPoints);
-    const edgeShapeLongitudes = new Int32Array(expandedPoints);
-    for (let edge = 0; edge < edges; edge += 1) {
-      const reference = references[edge];
-      if (!reference) continue;
-      const shape = (reference >>> 1) - 1;
-      const reversed = (reference & 1) === 1;
-      const count = sizes[shape];
-      const from = tableStarts[shape];
-      const to = edgeShapeOffsets[edge];
-      for (let point = 0; point < count; point += 1) {
-        const source = from + (reversed ? count - 1 - point : point);
-        edgeShapeLatitudes[to + point] = tableLatitudes[source];
-        edgeShapeLongitudes[to + point] = tableLongitudes[source];
-      }
-    }
-    assertGeographic(edgeShapeLatitudes, edgeShapeLongitudes, coordinateScale);
-    Object.assign(graph, { edgeShapeOffsets, edgeShapeLatitudes, edgeShapeLongitudes });
-  }
-  if (pairs) {
-    graph.turnRestrictionFromEdges = new Uint32Array(buffer.slice(offset, offset += pairs * 4));
-    graph.turnRestrictionToEdges = new Uint32Array(buffer.slice(offset, offset += pairs * 4));
-  }
-  if (runs) {
-    graph.turnRestrictionSequenceOffsets = new Uint32Array(buffer.slice(offset, offset += (runs + 1) * 4));
-    graph.turnRestrictionSequenceEdges = new Uint32Array(buffer.slice(offset, offset += runEdges * 4));
-    assertOffsets(graph.turnRestrictionSequenceOffsets, runs, runEdges, "turn restriction offsets");
-    for (const edge of graph.turnRestrictionSequenceEdges) if (edge >= edges) throw new Error("Invalid routing graph: turn restriction references an edge outside the graph.");
-  }
-  for (const edge of graph.turnRestrictionFromEdges ?? []) if (edge >= edges) throw new Error("Invalid routing graph: turn restriction references an edge outside the graph.");
-  for (const edge of graph.turnRestrictionToEdges ?? []) if (edge >= edges) throw new Error("Invalid routing graph: turn restriction references an edge outside the graph.");
-  return graph;
-}
-
-// src/types.ts
-var RouterError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "RouterError";
-  }
-  code;
-};
-
-// src/spatial-index.ts
-function cellKey(latitude, longitude, cellSizeDegrees) {
-  return `${Math.floor(latitude / cellSizeDegrees)}:${Math.floor(longitude / cellSizeDegrees)}`;
-}
-function coordinateFor(graph, nodeId) {
-  const scale = graph.coordinateScale ?? 1;
-  return { lat: graph.nodeLatitudes[nodeId] / scale, lng: graph.nodeLongitudes[nodeId] / scale };
-}
-function createSpatialIndex(graph, cellSizeDegrees = 0.02) {
-  if (!Number.isFinite(cellSizeDegrees) || cellSizeDegrees <= 0) throw new Error("Spatial index cell size must be positive.");
-  const buckets = /* @__PURE__ */ new Map();
-  for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) {
-    const coordinate = coordinateFor(graph, nodeId);
-    const key = cellKey(coordinate.lat, coordinate.lng, cellSizeDegrees);
-    const bucket = buckets.get(key);
-    if (bucket) bucket.push(nodeId);
-    else buckets.set(key, [nodeId]);
-  }
-  return {
-    cellSizeDegrees,
-    cells: new Map([...buckets].map(([key, ids]) => [key, Uint32Array.from(ids)]))
-  };
-}
-function withSpatialIndex(graph, cellSizeDegrees) {
-  return { ...graph, spatialIndex: createSpatialIndex(graph, cellSizeDegrees) };
-}
-function nearbyNodeIds(index, coordinate, maxDistanceMeters) {
-  const latitudeDelta = maxDistanceMeters / 110574;
-  const longitudeDelta = maxDistanceMeters / Math.max(1, 111320 * Math.cos(coordinate.lat * Math.PI / 180));
-  const minLatitudeCell = Math.floor((coordinate.lat - latitudeDelta) / index.cellSizeDegrees);
-  const maxLatitudeCell = Math.floor((coordinate.lat + latitudeDelta) / index.cellSizeDegrees);
-  const minLongitudeCell = Math.floor((coordinate.lng - longitudeDelta) / index.cellSizeDegrees);
-  const maxLongitudeCell = Math.floor((coordinate.lng + longitudeDelta) / index.cellSizeDegrees);
-  const ids = [];
-  for (let latitudeCell = minLatitudeCell; latitudeCell <= maxLatitudeCell; latitudeCell += 1) {
-    for (let longitudeCell = minLongitudeCell; longitudeCell <= maxLongitudeCell; longitudeCell += 1) {
-      const bucket = index.cells.get(`${latitudeCell}:${longitudeCell}`);
-      if (bucket) ids.push(...bucket);
-    }
-  }
-  return ids;
-}
-
-// src/turn-restrictions.ts
-function buildTurnRestrictionIndex(graph) {
-  const fromEdges = graph.turnRestrictionFromEdges;
-  const toEdges = graph.turnRestrictionToEdges;
-  if (!fromEdges || !toEdges || !fromEdges.length) return null;
-  if (fromEdges.length !== toEdges.length) throw new Error("Turn restriction arrays must have the same length.");
-  const index = /* @__PURE__ */ new Map();
-  for (let pair = 0; pair < fromEdges.length; pair += 1) {
-    const banned = index.get(fromEdges[pair]);
-    if (banned) banned.add(toEdges[pair]);
-    else index.set(fromEdges[pair], /* @__PURE__ */ new Set([toEdges[pair]]));
-  }
-  return index;
-}
-function isTurnBanned(index, fromEdge, toEdge) {
-  return index.get(fromEdge)?.has(toEdge) ?? false;
-}
-function packTurnRestrictions(pairs) {
-  const unique = /* @__PURE__ */ new Set();
-  const sorted = [];
-  for (const [fromEdge, toEdge] of pairs) {
-    const key = `${fromEdge}:${toEdge}`;
-    if (unique.has(key)) continue;
-    unique.add(key);
-    sorted.push([fromEdge, toEdge]);
-  }
-  sorted.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-  return {
-    turnRestrictionFromEdges: Uint32Array.from(sorted, (pair) => pair[0]),
-    turnRestrictionToEdges: Uint32Array.from(sorted, (pair) => pair[1])
-  };
-}
-function buildTurnSequenceIndex(graph) {
-  const offsets = graph.turnRestrictionSequenceOffsets;
-  const edges = graph.turnRestrictionSequenceEdges;
-  if (!offsets || !edges || offsets.length < 2) return null;
-  const sequences = [];
-  const startingAt = /* @__PURE__ */ new Map();
-  for (let index = 0; index + 1 < offsets.length; index += 1) {
-    const sequence = Array.from(edges.subarray(offsets[index], offsets[index + 1]));
-    if (sequence.length < 3) continue;
-    const id = sequences.length;
-    sequences.push(sequence);
-    const bucket = startingAt.get(sequence[0]);
-    if (bucket) bucket.push(id);
-    else startingAt.set(sequence[0], [id]);
-  }
-  if (!sequences.length) return null;
-  const stride = sequences.reduce((longest, sequence) => Math.max(longest, sequence.length), 0) + 1;
-  return { sequences, startingAt, stride };
-}
-function packTurnSequences(sequences) {
-  const kept = sequences.filter((sequence) => sequence.length >= 3);
-  const unique = new Map(kept.map((sequence) => [sequence.join(","), sequence]));
-  const ordered = [...unique.values()].sort((a, b) => a[0] - b[0] || a.length - b.length || a[1] - b[1]);
-  const turnRestrictionSequenceOffsets = new Uint32Array(ordered.length + 1);
-  for (let index = 0; index < ordered.length; index += 1) turnRestrictionSequenceOffsets[index + 1] = turnRestrictionSequenceOffsets[index] + ordered[index].length;
-  const turnRestrictionSequenceEdges = new Uint32Array(turnRestrictionSequenceOffsets[ordered.length]);
-  let at = 0;
-  for (const sequence of ordered) for (const edge of sequence) turnRestrictionSequenceEdges[at++] = edge;
-  return { turnRestrictionSequenceOffsets, turnRestrictionSequenceEdges };
-}
-
-// src/routing-profile.ts
-var MINIMUM_SPEED_KPH = 5;
-var MAXIMUM_SPEED_KPH = 150;
-var BLOCKED_ACCESS = /* @__PURE__ */ new Set(["no", "private", "agricultural", "forestry", "military", "emergency", "use_sidepath"]);
-var CAR_HIGHWAY_SPEEDS = {
-  motorway: 110,
-  motorway_link: 50,
-  trunk: 90,
-  trunk_link: 50,
-  primary: 70,
-  primary_link: 45,
-  secondary: 60,
-  secondary_link: 40,
-  tertiary: 50,
-  tertiary_link: 35,
-  unclassified: 35,
-  residential: 30,
-  living_street: 10,
-  service: 20,
-  road: 25
-};
-var CAR_ACCESS_KEYS = ["access", "vehicle", "motor_vehicle", "motorcar"];
-var CAR_RESTRICTION_KEYS = ["restriction", "restriction:vehicle", "restriction:motor_vehicle", "restriction:motorcar"];
-var CAR_EXCEPT_MODES = /* @__PURE__ */ new Set(["motorcar", "motor_vehicle", "vehicle"]);
-var TURN_RESTRICTION_KINDS = {
-  no_left_turn: "no",
-  no_right_turn: "no",
-  no_straight_on: "no",
-  no_u_turn: "no",
-  no_entry: "no",
-  no_exit: "no",
-  only_left_turn: "only",
-  only_right_turn: "only",
-  only_straight_on: "only",
-  only_u_turn: "only"
-};
-var IMPLICITLY_ONEWAY = /* @__PURE__ */ new Set(["motorway", "motorway_link"]);
-function clampSpeed(value) {
-  if (!Number.isFinite(value)) return MINIMUM_SPEED_KPH;
-  return Math.min(MAXIMUM_SPEED_KPH, Math.max(MINIMUM_SPEED_KPH, value));
-}
-function parseMaxSpeedKph(value) {
-  if (!value) return null;
-  const text = value.trim().toLowerCase();
-  if (text === "walk") return 7;
-  const match = /^(\d+(?:\.\d+)?)\s*(mph|km\/h|kmh|kph|knots)?$/.exec(text);
-  if (!match) return null;
-  const amount = Number(match[1]);
-  if (!Number.isFinite(amount) || amount <= 0) return null;
-  if (match[2] === "mph") return amount * 1.609344;
-  if (match[2] === "knots") return amount * 1.852;
-  return amount;
-}
-function accessAllowed(tags, keys) {
-  let allowed = true;
-  for (const key of keys) {
-    const value = tags[key];
-    if (value === void 0) continue;
-    allowed = !BLOCKED_ACCESS.has(value);
-  }
-  return allowed;
-}
-function onewayDirections(tags, highway) {
-  const oneway = tags.oneway?.trim().toLowerCase();
-  if (oneway === "yes" || oneway === "true" || oneway === "1") return { forward: true, backward: false };
-  if (oneway === "-1" || oneway === "reverse") return { forward: false, backward: true };
-  if (oneway !== void 0 && oneway !== "") return { forward: true, backward: true };
-  const junction = tags.junction?.trim().toLowerCase();
-  if (junction === "roundabout" || junction === "circular") return { forward: true, backward: false };
-  if (highway && IMPLICITLY_ONEWAY.has(highway)) return { forward: true, backward: false };
-  return { forward: true, backward: true };
-}
-var carRoutingProfile = {
-  name: "car",
-  wayTagKeys: ["highway", "oneway", "junction", "access", "vehicle", "motor_vehicle", "motorcar", "maxspeed", "maxspeed:forward", "maxspeed:backward"],
-  relationTagKeys: ["type", "except", ...CAR_RESTRICTION_KEYS],
-  maxSpeedKph: MAXIMUM_SPEED_KPH,
-  evaluateWay(tags) {
-    const highway = tags.highway;
-    if (!highway || !(highway in CAR_HIGHWAY_SPEEDS)) return null;
-    if (!accessAllowed(tags, CAR_ACCESS_KEYS)) return null;
-    const { forward, backward } = onewayDirections(tags, highway);
-    if (!forward && !backward) return null;
-    const base = parseMaxSpeedKph(tags.maxspeed) ?? CAR_HIGHWAY_SPEEDS[highway];
-    return {
-      forward,
-      backward,
-      forwardSpeedKph: clampSpeed(parseMaxSpeedKph(tags["maxspeed:forward"]) ?? base),
-      backwardSpeedKph: clampSpeed(parseMaxSpeedKph(tags["maxspeed:backward"]) ?? base)
-    };
-  },
-  evaluateTurnRestriction(tags) {
-    if (tags.type !== "restriction") return null;
-    const except = tags.except?.split(";").map((mode) => mode.trim().toLowerCase()) ?? [];
-    if (except.some((mode) => CAR_EXCEPT_MODES.has(mode))) return null;
-    let value;
-    for (const key of CAR_RESTRICTION_KEYS) if (tags[key] !== void 0) value = tags[key];
-    if (!value) return null;
-    const kind = TURN_RESTRICTION_KINDS[value.trim().toLowerCase()];
-    return kind ? { kind, value } : null;
-  }
-};
-var routingProfiles = { car: carRoutingProfile };
-function getRoutingProfile(name) {
-  const profile = routingProfiles[name];
-  if (!profile) throw new Error(`Unknown routing profile "${name}". Available: ${Object.keys(routingProfiles).join(", ")}.`);
-  return profile;
-}
-
-// src/edge-index.ts
-var MAX_CELLS_PER_EDGE = 4096;
-function cellKey2(latitudeCell, longitudeCell) {
-  return `${latitudeCell}:${longitudeCell}`;
-}
-function edgeSource(graph, edge) {
-  let low = 0;
-  let high = graph.nodeLatitudes.length - 1;
-  while (low < high) {
-    const middle = low + high + 1 >> 1;
-    if (graph.edgeOffsets[middle] <= edge) low = middle;
-    else high = middle - 1;
-  }
-  return low;
-}
-function edgePolyline(graph, edge, source = edgeSource(graph, edge)) {
-  const scale = graph.coordinateScale ?? 1;
-  const target = graph.edgeTargets[edge];
-  const points = [{ lat: graph.nodeLatitudes[source] / scale, lng: graph.nodeLongitudes[source] / scale }];
-  if (graph.edgeShapeOffsets && graph.edgeShapeLatitudes && graph.edgeShapeLongitudes) {
-    for (let point = graph.edgeShapeOffsets[edge]; point < graph.edgeShapeOffsets[edge + 1]; point += 1) {
-      points.push({ lat: graph.edgeShapeLatitudes[point] / scale, lng: graph.edgeShapeLongitudes[point] / scale });
-    }
-  }
-  points.push({ lat: graph.nodeLatitudes[target] / scale, lng: graph.nodeLongitudes[target] / scale });
-  return points;
-}
-function createEdgeSpatialIndex(graph, cellSizeDegrees = 0.02) {
-  if (!Number.isFinite(cellSizeDegrees) || cellSizeDegrees <= 0) throw new Error("Edge index cell size must be positive.");
-  const scale = graph.coordinateScale ?? 1;
-  const buckets = /* @__PURE__ */ new Map();
-  const oversized = [];
-  const shapeOffsets = graph.edgeShapeOffsets;
-  const shapeLatitudes = graph.edgeShapeLatitudes;
-  const shapeLongitudes = graph.edgeShapeLongitudes;
-  for (let source = 0; source < graph.nodeLatitudes.length; source += 1) {
-    const sourceLat = graph.nodeLatitudes[source] / scale;
-    const sourceLng = graph.nodeLongitudes[source] / scale;
-    for (let edge = graph.edgeOffsets[source]; edge < graph.edgeOffsets[source + 1]; edge += 1) {
-      const target = graph.edgeTargets[edge];
-      let minLat = Math.min(sourceLat, graph.nodeLatitudes[target] / scale);
-      let maxLat = Math.max(sourceLat, graph.nodeLatitudes[target] / scale);
-      let minLng = Math.min(sourceLng, graph.nodeLongitudes[target] / scale);
-      let maxLng = Math.max(sourceLng, graph.nodeLongitudes[target] / scale);
-      if (shapeOffsets && shapeLatitudes && shapeLongitudes) {
-        for (let point = shapeOffsets[edge]; point < shapeOffsets[edge + 1]; point += 1) {
-          const lat = shapeLatitudes[point] / scale;
-          const lng = shapeLongitudes[point] / scale;
-          if (lat < minLat) minLat = lat;
-          else if (lat > maxLat) maxLat = lat;
-          if (lng < minLng) minLng = lng;
-          else if (lng > maxLng) maxLng = lng;
-        }
-      }
-      const minLatCell = Math.floor(minLat / cellSizeDegrees);
-      const maxLatCell = Math.floor(maxLat / cellSizeDegrees);
-      const minLngCell = Math.floor(minLng / cellSizeDegrees);
-      const maxLngCell = Math.floor(maxLng / cellSizeDegrees);
-      if (!Number.isFinite(minLatCell) || !Number.isFinite(minLngCell) || (maxLatCell - minLatCell + 1) * (maxLngCell - minLngCell + 1) > MAX_CELLS_PER_EDGE) {
-        oversized.push(edge);
-        continue;
-      }
-      for (let latitudeCell = minLatCell; latitudeCell <= maxLatCell; latitudeCell += 1) {
-        for (let longitudeCell = minLngCell; longitudeCell <= maxLngCell; longitudeCell += 1) {
-          const key = cellKey2(latitudeCell, longitudeCell);
-          const bucket = buckets.get(key);
-          if (bucket) bucket.push(edge);
-          else buckets.set(key, [edge]);
-        }
-      }
-    }
-  }
-  return { cellSizeDegrees, cells: new Map([...buckets].map(([key, ids]) => [key, Uint32Array.from(ids)])), oversized: Uint32Array.from(oversized) };
-}
-var indexes = /* @__PURE__ */ new WeakMap();
-function edgeSpatialIndexFor(graph, cellSizeDegrees) {
-  let index = indexes.get(graph);
-  if (!index) {
-    index = createEdgeSpatialIndex(graph, cellSizeDegrees);
-    indexes.set(graph, index);
-  }
-  return index;
-}
-function nearbyEdgeIds(index, coordinate, maxDistanceMeters) {
-  const latitudeDelta = maxDistanceMeters / 110574;
-  const longitudeDelta = maxDistanceMeters / Math.max(1, 111320 * Math.cos(coordinate.lat * Math.PI / 180));
-  const minLatitudeCell = Math.floor((coordinate.lat - latitudeDelta) / index.cellSizeDegrees);
-  const maxLatitudeCell = Math.floor((coordinate.lat + latitudeDelta) / index.cellSizeDegrees);
-  const minLongitudeCell = Math.floor((coordinate.lng - longitudeDelta) / index.cellSizeDegrees);
-  const maxLongitudeCell = Math.floor((coordinate.lng + longitudeDelta) / index.cellSizeDegrees);
-  const ids = new Set(index.oversized);
-  for (let latitudeCell = minLatitudeCell; latitudeCell <= maxLatitudeCell; latitudeCell += 1) {
-    for (let longitudeCell = minLongitudeCell; longitudeCell <= maxLongitudeCell; longitudeCell += 1) {
-      const bucket = index.cells.get(cellKey2(latitudeCell, longitudeCell));
-      if (bucket) for (const id of bucket) ids.add(id);
-    }
-  }
-  return ids;
-}
-
-// src/snap.ts
-var EARTH_RADIUS_METERS = 6371e3;
-var METERS_PER_DEGREE_LATITUDE = 110574;
-var METERS_PER_DEGREE_LONGITUDE = 111320;
-var NODE_SNAP_TOLERANCE_METERS = 1;
-var TIE_TOLERANCE_METERS = 0.5;
-function haversineMeters(a, b) {
-  const radians = Math.PI / 180;
-  const dLat = (b.lat - a.lat) * radians;
-  const dLng = (b.lng - a.lng) * radians;
-  const latA = a.lat * radians;
-  const latB = b.lat * radians;
-  const value = Math.sin(dLat / 2) ** 2 + Math.cos(latA) * Math.cos(latB) * Math.sin(dLng / 2) ** 2;
-  return EARTH_RADIUS_METERS * 2 * Math.atan2(Math.sqrt(value), Math.sqrt(1 - value));
-}
-function coordinateFor2(graph, nodeId) {
-  const scale = graph.coordinateScale ?? 1;
-  return { lat: graph.nodeLatitudes[nodeId] / scale, lng: graph.nodeLongitudes[nodeId] / scale };
-}
-function projectOntoPolyline(points, query) {
-  const longitudeScale = METERS_PER_DEGREE_LONGITUDE * Math.cos(query.lat * Math.PI / 180);
-  const x = (point) => (point.lng - query.lng) * longitudeScale;
-  const y = (point) => (point.lat - query.lat) * METERS_PER_DEGREE_LATITUDE;
-  let best = { distanceMeters: Infinity, vertexIndex: 0, along: 0, point: points[0] };
-  let travelled = 0;
-  let total = 0;
-  for (let index = 1; index < points.length; index += 1) {
-    const start = points[index - 1];
-    const end = points[index];
-    const segmentMeters = haversineMeters(start, end);
-    const dx = x(end) - x(start);
-    const dy = y(end) - y(start);
-    const lengthSquared = dx * dx + dy * dy;
-    const t = lengthSquared ? Math.max(0, Math.min(1, (-x(start) * dx + -y(start) * dy) / lengthSquared)) : 0;
-    const closest = { lat: start.lat + (end.lat - start.lat) * t, lng: start.lng + (end.lng - start.lng) * t };
-    const distanceMeters = haversineMeters(query, closest);
-    if (distanceMeters < best.distanceMeters) {
-      best = { distanceMeters, vertexIndex: index - 1, along: travelled + segmentMeters * t, point: closest };
-    }
-    travelled += segmentMeters;
-    total += segmentMeters;
-  }
-  return { ...best, totalMeters: total };
-}
-function snapToGraph(graph, coordinate, maxDistanceMeters = 500) {
-  const candidates = graph.edgeTargets.length ? nearbyEdgeIds(edgeSpatialIndexFor(graph), coordinate, maxDistanceMeters) : /* @__PURE__ */ new Set();
-  let best = null;
-  const projections = [];
-  for (const edge of candidates) {
-    const source = edgeSource(graph, edge);
-    const polyline = edgePolyline(graph, edge, source);
-    const projected = projectOntoPolyline(polyline, coordinate);
-    if (projected.distanceMeters > maxDistanceMeters) continue;
-    const projection = {
-      edge,
-      source,
-      target: graph.edgeTargets[edge],
-      fraction: projected.totalMeters ? projected.along / projected.totalMeters : 0,
-      point: projected.point,
-      distanceMeters: projected.distanceMeters,
-      vertexIndex: projected.vertexIndex,
-      polyline
-    };
-    projections.push(projection);
-    if (!best || projection.distanceMeters < best.distanceMeters) best = projection;
-  }
-  if (!best) {
-    const node = nearestNodeWithin(graph, coordinate, maxDistanceMeters);
-    return node === null ? null : { kind: "node", node, point: coordinateFor2(graph, node), distanceMeters: haversineMeters(coordinate, coordinateFor2(graph, node)) };
-  }
-  const startMeters = best.fraction * totalLengthOf(best);
-  const endMeters = (1 - best.fraction) * totalLengthOf(best);
-  if (startMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.source, point: best.polyline[0], distanceMeters: best.distanceMeters };
-  if (endMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.target, point: best.polyline[best.polyline.length - 1], distanceMeters: best.distanceMeters };
-  const sameRoad = projections.filter((projection) => projection.distanceMeters <= best.distanceMeters + TIE_TOLERANCE_METERS);
-  return { kind: "edge", projections: sameRoad, point: best.point, distanceMeters: best.distanceMeters };
-}
-function totalLengthOf(projection) {
-  let total = 0;
-  for (let index = 1; index < projection.polyline.length; index += 1) total += haversineMeters(projection.polyline[index - 1], projection.polyline[index]);
-  return total;
-}
-function nearestNodeWithin(graph, coordinate, maxDistanceMeters) {
-  let closest = null;
-  let closestDistance = maxDistanceMeters;
-  const check = (nodeId) => {
-    const distance = haversineMeters(coordinate, coordinateFor2(graph, nodeId));
-    if (distance <= closestDistance) {
-      closest = nodeId;
-      closestDistance = distance;
-    }
-  };
-  if (graph.spatialIndex) for (const nodeId of nearbyNodeIds(graph.spatialIndex, coordinate, maxDistanceMeters)) check(nodeId);
-  else for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) check(nodeId);
-  return closest;
-}
-function geometryAfter(projection) {
-  return [projection.point, ...projection.polyline.slice(projection.vertexIndex + 1, projection.polyline.length - 1)];
-}
-function geometryBefore(projection) {
-  return [...projection.polyline.slice(1, projection.vertexIndex + 1), projection.point];
-}
-function geometryBetween(from, to) {
-  return [from.point, ...from.polyline.slice(from.vertexIndex + 1, to.vertexIndex + 1), to.point];
-}
-
-// src/priority-queue.ts
-var MinPriorityQueue = class {
-  values = [];
-  get size() {
-    return this.values.length;
-  }
-  /** The smallest priority still queued, or Infinity when empty. A* uses it to
-   *  stop once no queued state can beat the best finish found so far. */
-  get minimumPriority() {
-    return this.values.length ? this.values[0].priority : Infinity;
-  }
-  push(value, priority) {
-    const entry = { value, priority };
-    this.values.push(entry);
-    let index = this.values.length - 1;
-    while (index > 0) {
-      const parent = Math.floor((index - 1) / 2);
-      if (this.values[parent].priority <= entry.priority) break;
-      this.values[index] = this.values[parent];
-      index = parent;
-    }
-    this.values[index] = entry;
-  }
-  pop() {
-    if (!this.values.length) return void 0;
-    const first = this.values[0];
-    const last = this.values.pop();
-    if (this.values.length) {
-      let index = 0;
-      while (true) {
-        let child = index * 2 + 1;
-        if (child >= this.values.length) break;
-        if (child + 1 < this.values.length && this.values[child + 1].priority < this.values[child].priority) child++;
-        if (this.values[child].priority >= last.priority) break;
-        this.values[index] = this.values[child];
-        index = child;
-      }
-      this.values[index] = last;
-    }
-    return first.value;
-  }
-};
-
-// src/router.ts
-var MAX_CAR_SPEED_MPS = carRoutingProfile.maxSpeedKph * 1e3 / 3600;
-function assertGraph(graph) {
-  const nodes = graph.nodeLatitudes.length;
-  const edges = graph.edgeTargets.length;
-  if (!nodes || graph.nodeLongitudes.length !== nodes || graph.edgeOffsets.length !== nodes + 1 || graph.edgeDistancesMeters.length !== edges || graph.edgeDurationsSeconds.length !== edges || graph.edgeOffsets[nodes] !== edges) {
-    throw new Error("Invalid road graph");
-  }
-}
-function findNearestNode(graph, coordinate, maxDistanceMeters = 500) {
-  let closest = null;
-  let closestDistance = maxDistanceMeters;
-  const checkNode = (nodeId) => {
-    const distance = haversineMeters(coordinate, coordinateFor2(graph, nodeId));
-    if (distance <= closestDistance) {
-      closest = nodeId;
-      closestDistance = distance;
-    }
-  };
-  if (graph.spatialIndex) {
-    for (const nodeId of nearbyNodeIds(graph.spatialIndex, coordinate, maxDistanceMeters)) checkNode(nodeId);
-  } else {
-    for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) checkNode(nodeId);
-  }
-  return closest;
-}
-function searchContext(graph, destinationPoint, preference) {
-  const distanceScale = graph.edgeDistanceScale ?? 1;
-  const durationScale = graph.edgeDurationScale ?? 1;
-  return {
-    costOf: (edge) => preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale,
-    heuristicFor: (node) => {
-      const remaining = haversineMeters(coordinateFor2(graph, node), destinationPoint);
-      return preference === "fastest" ? remaining / MAX_CAR_SPEED_MPS : remaining;
-    }
-  };
-}
-function searchByNode(graph, seeds, finishers, destinationPoint, preference, costBound = Infinity) {
-  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference);
-  const nodeCount = graph.nodeLatitudes.length;
-  const costs = new Float64Array(nodeCount).fill(Infinity);
-  const previousNode = new Int32Array(nodeCount).fill(-1);
-  const previousEdge = new Int32Array(nodeCount).fill(-1);
-  const seedAt = /* @__PURE__ */ new Map();
-  const queue = new MinPriorityQueue();
-  for (const seed of seeds) {
-    if (seed.cost >= costs[seed.node]) continue;
-    costs[seed.node] = seed.cost;
-    seedAt.set(seed.node, seed);
-    queue.push(seed.node, seed.cost + heuristicFor(seed.node));
-  }
-  let best = costBound;
-  let bestNode = -1;
-  let bestFinisher = null;
-  while (queue.size) {
-    if (queue.minimumPriority >= best) break;
-    const node2 = queue.pop();
-    for (const finisher of finishers.get(node2) ?? []) {
-      const total = costs[node2] + finisher.cost;
-      if (total < best) {
-        best = total;
-        bestNode = node2;
-        bestFinisher = finisher;
-      }
-    }
-    for (let edge = graph.edgeOffsets[node2]; edge < graph.edgeOffsets[node2 + 1]; edge += 1) {
-      const target = graph.edgeTargets[edge];
-      const cost = costs[node2] + costOf(edge);
-      if (cost >= costs[target]) continue;
-      costs[target] = cost;
-      previousNode[target] = node2;
-      previousEdge[target] = edge;
-      queue.push(target, cost + heuristicFor(target));
-    }
-  }
-  if (!bestFinisher) return null;
-  const edges = [];
-  let node = bestNode;
-  while (previousNode[node] !== -1) {
-    edges.push(previousEdge[node]);
-    node = previousNode[node];
-  }
-  edges.reverse();
-  return { edges, finisher: bestFinisher, seed: seedAt.get(node) };
-}
-function searchByEdge(graph, seeds, finishers, destinationPoint, preference, restrictions, sequenceIndex, costBound = Infinity) {
-  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference);
-  const edgeCount = graph.edgeTargets.length;
-  const costs = new Float64Array(edgeCount).fill(Infinity);
-  const previousState = new Int32Array(edgeCount).fill(-1);
-  const seedOf = /* @__PURE__ */ new Map();
-  const queue = new MinPriorityQueue();
-  const sequences = sequenceIndex?.sequences ?? [];
-  const startingAt = sequenceIndex?.startingAt;
-  const partialEdge = [];
-  const partialMatches = [];
-  const partialCost = [];
-  const partialPrevious = [];
-  const partialIds = /* @__PURE__ */ new Map();
-  const stride = sequenceIndex?.stride ?? 1;
-  const encode = (sequence, position) => sequence * stride + position;
-  const edgeOf = (state) => state < edgeCount ? state : partialEdge[state - edgeCount];
-  const matchesOf = (state) => state < edgeCount ? void 0 : partialMatches[state - edgeCount];
-  const costOfState = (state) => state < edgeCount ? costs[state] : partialCost[state - edgeCount];
-  const relax = (state, cost, from, seed2) => {
-    if (state < edgeCount) {
-      if (cost >= costs[state]) return;
-      costs[state] = cost;
-      previousState[state] = from;
-      if (from === -1 && seed2) seedOf.set(state, seed2);
-    } else {
-      const slot = state - edgeCount;
-      if (cost >= partialCost[slot]) return;
-      partialCost[slot] = cost;
-      partialPrevious[slot] = from;
-    }
-    queue.push(state, cost + heuristicFor(graph.edgeTargets[edgeOf(state)]));
-  };
-  const stateFor = (edge, matches) => {
-    if (!matches.length) return edge;
-    const key = `${edge}:${matches.sort((a, b) => a - b).join(",")}`;
-    let id = partialIds.get(key);
-    if (id === void 0) {
-      id = edgeCount + partialEdge.length;
-      partialIds.set(key, id);
-      partialEdge.push(edge);
-      partialMatches.push(matches);
-      partialCost.push(Infinity);
-      partialPrevious.push(-1);
-    }
-    return id;
-  };
-  const advance = (edge, matches, next) => {
-    const carried = [];
-    if (matches) {
-      for (const match of matches) {
-        const sequence = sequences[Math.floor(match / stride)];
-        const position = match % stride;
-        if (sequence[position + 1] !== next) continue;
-        if (position + 2 === sequence.length) return null;
-        carried.push(encode(Math.floor(match / stride), position + 1));
-      }
-    }
-    for (const id of startingAt?.get(edge) ?? []) {
-      if (sequences[id][1] !== next) continue;
-      if (sequences[id].length === 2) return null;
-      carried.push(encode(id, 1));
-    }
-    return carried;
-  };
-  let best = costBound;
-  let bestArrival = -1;
-  let bestFinisher = null;
-  let bestSeed = null;
-  const considerFinishers = (state, node, seed2) => {
-    const edge = edgeOf(state);
-    const banned = restrictions?.get(edge);
-    for (const finisher of finishers.get(node) ?? []) {
-      if (finisher.edge >= 0 && banned?.has(finisher.edge)) continue;
-      if (finisher.edge >= 0 && advance(edge, matchesOf(state), finisher.edge) === null) continue;
-      const total = costOfState(state) + finisher.cost;
-      if (total < best) {
-        best = total;
-        bestArrival = state;
-        bestFinisher = finisher;
-        bestSeed = seed2;
-      }
-    }
-  };
-  for (const seed2 of seeds) {
-    if (seed2.edge >= 0) {
-      relax(seed2.edge, seed2.cost, -1, seed2);
-      considerFinishers(seed2.edge, seed2.node, seed2);
-      continue;
-    }
-    for (const finisher of finishers.get(seed2.node) ?? []) {
-      const total = seed2.cost + finisher.cost;
-      if (total < best) {
-        best = total;
-        bestArrival = -1;
-        bestFinisher = finisher;
-        bestSeed = seed2;
-      }
-    }
-    for (let edge = graph.edgeOffsets[seed2.node]; edge < graph.edgeOffsets[seed2.node + 1]; edge += 1) {
-      relax(edge, seed2.cost + costOf(edge), -1, seed2);
-    }
-  }
-  while (queue.size) {
-    if (queue.minimumPriority >= best) break;
-    const state = queue.pop();
-    const edge = edgeOf(state);
-    const matches = matchesOf(state);
-    const node = graph.edgeTargets[edge];
-    const banned = restrictions?.get(edge);
-    considerFinishers(state, node, null);
-    for (let next = graph.edgeOffsets[node]; next < graph.edgeOffsets[node + 1]; next += 1) {
-      if (banned?.has(next)) continue;
-      const carried = advance(edge, matches, next);
-      if (carried === null) continue;
-      relax(stateFor(next, carried), costOfState(state) + costOf(next), state, null);
-    }
-  }
-  if (!bestFinisher) return null;
-  const chain = [];
-  for (let state = bestArrival; state !== -1; state = state < edgeCount ? previousState[state] : partialPrevious[state - edgeCount]) {
-    chain.push(edgeOf(state));
-  }
-  chain.reverse();
-  const seed = bestSeed ?? (chain.length ? seedOf.get(chain[0]) : seeds[0]);
-  if (seed.edge >= 0 && chain[0] === seed.edge) chain.shift();
-  return { edges: chain, finisher: bestFinisher, seed };
-}
-function seedsFor(snap, costOf) {
-  if (snap.kind === "node") return [{ node: snap.node, edge: -1, cost: 0 }];
-  return snap.projections.map((projection) => ({
-    node: projection.target,
-    edge: projection.edge,
-    cost: (1 - projection.fraction) * costOf(projection.edge)
-  }));
-}
-function finishersFor(snap, costOf) {
-  if (snap.kind === "node") return [{ node: snap.node, edge: -1, cost: 0 }];
-  return snap.projections.map((projection) => ({
-    node: projection.source,
-    edge: projection.edge,
-    cost: projection.fraction * costOf(projection.edge)
-  }));
-}
-function projectionOf(snap, edge) {
-  return snap.kind === "edge" ? snap.projections.find((projection) => projection.edge === edge) : void 0;
-}
-function snapSummary(snap) {
-  return snap.kind === "node" ? { node: snap.node, edge: -1, point: snap.point, distanceMeters: snap.distanceMeters } : { node: -1, edge: snap.projections[0].edge, point: snap.point, distanceMeters: snap.distanceMeters };
-}
-function route(graph, from, to, preference = "fastest", options = {}) {
-  assertGraph(graph);
-  const originSnap = snapToGraph(graph, from);
-  if (!originSnap) throw new RouterError("ORIGIN_NOT_ON_GRAPH", "No routable road is close to the origin.");
-  const destinationSnap = snapToGraph(graph, to);
-  if (!destinationSnap) throw new RouterError("DESTINATION_NOT_ON_GRAPH", "No routable road is close to the destination.");
-  const distanceScale = graph.edgeDistanceScale ?? 1;
-  const durationScale = graph.edgeDurationScale ?? 1;
-  const costOf = (edge) => preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale;
-  const seeds = seedsFor(originSnap, costOf);
-  const finisherList = finishersFor(destinationSnap, costOf);
-  const finishers = /* @__PURE__ */ new Map();
-  for (const finisher of finisherList) {
-    const bucket = finishers.get(finisher.node);
-    if (bucket) bucket.push(finisher);
-    else finishers.set(finisher.node, [finisher]);
-  }
-  let direct = null;
-  if (originSnap.kind === "edge" && destinationSnap.kind === "edge") {
-    for (const origin of originSnap.projections) {
-      const destination = projectionOf(destinationSnap, origin.edge);
-      if (!destination || destination.fraction < origin.fraction) continue;
-      const cost = (destination.fraction - origin.fraction) * costOf(origin.edge);
-      if (!direct || cost < direct.cost) direct = { origin, destination, cost };
-    }
-  }
-  const sameNode = originSnap.kind === "node" && destinationSnap.kind === "node" && originSnap.node === destinationSnap.node;
-  const costBound = options.costBound ?? Infinity;
-  const restrictions = buildTurnRestrictionIndex(graph);
-  const sequenceIndex = buildTurnSequenceIndex(graph);
-  const outcome = sameNode ? { edges: [], finisher: finisherList[0], seed: seeds[0] } : restrictions || sequenceIndex ? searchByEdge(graph, seeds, finishers, destinationSnap.point, preference, restrictions, sequenceIndex, costBound) : searchByNode(graph, seeds, finishers, destinationSnap.point, preference, costBound);
-  if (direct && direct.cost >= costBound) direct = null;
-  if (!outcome && !direct) throw new RouterError("NO_ROUTE", "No car route connects the selected points.");
-  const searchCost = outcome ? outcome.seed.cost + outcome.edges.reduce((sum, edge) => sum + costOf(edge), 0) + outcome.finisher.cost : Infinity;
-  const partial = (projection, fraction) => ({
-    distance: fraction * graph.edgeDistancesMeters[projection.edge] * distanceScale,
-    duration: fraction * graph.edgeDurationsSeconds[projection.edge] * durationScale
-  });
-  const coordinates = [];
-  const push = (point) => coordinates.push([point.lng, point.lat]);
-  const nodeIds = [];
-  let edgeIds = [];
-  let distanceMeters = 0;
-  let durationSeconds = 0;
-  if (direct && direct.cost <= searchCost) {
-    for (const point of geometryBetween(direct.origin, direct.destination)) push(point);
-    const span = partial(direct.origin, direct.destination.fraction - direct.origin.fraction);
-    distanceMeters = span.distance;
-    durationSeconds = span.duration;
-  } else {
-    const { edges, finisher, seed } = outcome;
-    edgeIds = edges;
-    const entry = seed.edge >= 0 ? projectionOf(originSnap, seed.edge) : void 0;
-    push(originSnap.point);
-    if (entry) {
-      for (const point of geometryAfter(entry).slice(1)) push(point);
-      const span = partial(entry, 1 - entry.fraction);
-      distanceMeters += span.distance;
-      durationSeconds += span.duration;
-      nodeIds.push(entry.target);
-      push(coordinateFor2(graph, entry.target));
-    } else {
-      nodeIds.push(seed.node);
-    }
-    const scale = graph.coordinateScale ?? 1;
-    for (const edge of edges) {
-      distanceMeters += graph.edgeDistancesMeters[edge] * distanceScale;
-      durationSeconds += graph.edgeDurationsSeconds[edge] * durationScale;
-      if (graph.edgeShapeOffsets && graph.edgeShapeLatitudes && graph.edgeShapeLongitudes) {
-        for (let point = graph.edgeShapeOffsets[edge]; point < graph.edgeShapeOffsets[edge + 1]; point += 1) {
-          coordinates.push([graph.edgeShapeLongitudes[point] / scale, graph.edgeShapeLatitudes[point] / scale]);
-        }
-      }
-      nodeIds.push(graph.edgeTargets[edge]);
-      push(coordinateFor2(graph, graph.edgeTargets[edge]));
-    }
-    const exit = finisher.edge >= 0 ? projectionOf(destinationSnap, finisher.edge) : void 0;
-    if (exit) {
-      for (const point of geometryBefore(exit)) push(point);
-      const span = partial(exit, exit.fraction);
-      distanceMeters += span.distance;
-      durationSeconds += span.duration;
-    }
-  }
-  return {
-    nodeIds,
-    edgeIds,
-    distanceMeters,
-    durationSeconds,
-    originSnap: snapSummary(originSnap),
-    destinationSnap: snapSummary(destinationSnap),
-    geometry: { type: "LineString", coordinates }
-  };
-}
-
-export {
-  zigzag,
-  unzigzag,
-  VarintWriter,
-  VarintReader,
-  encodeGraph,
-  decodeGraph,
-  encodeCompactGraph,
-  RouterError,
-  createSpatialIndex,
-  withSpatialIndex,
-  buildTurnRestrictionIndex,
-  isTurnBanned,
-  packTurnRestrictions,
-  buildTurnSequenceIndex,
-  packTurnSequences,
-  parseMaxSpeedKph,
-  carRoutingProfile,
-  routingProfiles,
-  getRoutingProfile,
-  edgeSource,
-  edgePolyline,
-  createEdgeSpatialIndex,
-  edgeSpatialIndexFor,
-  nearbyEdgeIds,
-  snapToGraph,
-  findNearestNode,
-  route
-};