roadgraph-router-v2 0.1.0 → 0.3.0

package/dist/chunk-QSIKDM4A.js

@@ -0,0 +1,2690 @@
+// src/access.ts
+function accessMaskFor(edges, allowed) {
+  const mask = new Uint8Array(edges + 7 >> 3);
+  for (let edge = 0; edge < edges; edge += 1) if (allowed(edge)) mask[edge >> 3] |= 1 << (edge & 7);
+  return mask;
+}
+function edgeAllowed(mask, edge) {
+  return mask === void 0 || (mask[edge >> 3] & 1 << (edge & 7)) !== 0;
+}
+function allowsEverything(mask, edges) {
+  for (let edge = 0; edge < edges; edge += 1) if (!edgeAllowed(mask, edge)) return false;
+  return true;
+}
+
+// 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/speed.ts
+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;
+}
+
+// src/conditional.ts
+var MAX_STORED_VALUES = 65536;
+function answered(circumstances) {
+  const yes = /* @__PURE__ */ new Set();
+  for (const list of [circumstances?.conditions, circumstances?.userGroups, circumstances?.purposes]) {
+    for (const name of list ?? []) yes.add(name.trim().toLowerCase());
+  }
+  return yes;
+}
+var KNOWN_CIRCUMSTANCES = /* @__PURE__ */ new Set([
+  "wet",
+  "dry",
+  "snow",
+  "ice",
+  "fog",
+  "rain",
+  "disabled",
+  "resident",
+  "residents",
+  "customers",
+  "employees",
+  "emergency",
+  "permit",
+  "school",
+  "delivery",
+  "destination",
+  "agricultural",
+  "forestry",
+  "loading",
+  "unloading"
+]);
+var WEEKDAYS = ["mo", "tu", "we", "th", "fr", "sa", "su"];
+var MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+function splitOutsideBrackets(text, separator) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (character === "(") depth += 1;
+    else if (character === ")") depth = Math.max(0, depth - 1);
+    else if (character === separator && depth === 0) {
+      parts.push(text.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+function parseClock(text) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(text.trim());
+  if (!match) return null;
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  if (hours > 24 || minutes > 59) return null;
+  if (hours === 24 && minutes !== 0) return null;
+  return hours * 60 + minutes;
+}
+function parseIndexedRange(text, table) {
+  const [from, to] = text.split("-").map((part) => part.trim().toLowerCase().slice(0, 3));
+  const start = table.indexOf(from);
+  if (start < 0) return null;
+  if (to === void 0) return { from: start, to: start };
+  const end = table.indexOf(to);
+  return end < 0 ? null : { from: start, to: end };
+}
+function parseVehicleComparison(text) {
+  const match = /^(weight|height|width|length)\s*(<=|>=|<|>|=)\s*(\d+(?:\.\d+)?)$/.exec(text.trim().toLowerCase());
+  if (!match) return null;
+  return { property: match[1], operator: match[2], amount: Number(match[3]) };
+}
+function parseCondition(text) {
+  const condition = {};
+  const cleaned = text.trim().replace(/^\(|\)$/g, "").trim();
+  if (!cleaned) return { unreadable: text };
+  if (cleaned.toLowerCase() === "24/7") return { times: [{ from: 0, to: 1440 }] };
+  for (const token of cleaned.split(/\s+(?:and|AND)\s+|\s+/).filter(Boolean)) {
+    const lower = token.toLowerCase().replace(/,$/, "");
+    if (lower === "ph") {
+      condition.publicHoliday = true;
+      continue;
+    }
+    const comparison = parseVehicleComparison(lower);
+    if (comparison) {
+      (condition.vehicle ??= []).push(comparison);
+      continue;
+    }
+    const pieces = lower.split(",").filter(Boolean);
+    const spans = [];
+    const days = [];
+    const months = [];
+    let understood = true;
+    for (const piece of pieces) {
+      const [left, right] = piece.split("-");
+      const from = parseClock(left ?? "");
+      if (from !== null && right !== void 0) {
+        const to = parseClock(right);
+        if (to === null) {
+          understood = false;
+          break;
+        }
+        spans.push({ from, to });
+        continue;
+      }
+      const day = parseIndexedRange(piece, WEEKDAYS);
+      if (day) {
+        days.push(day);
+        continue;
+      }
+      const month = parseIndexedRange(piece, MONTHS);
+      if (month) {
+        months.push(month);
+        continue;
+      }
+      if (KNOWN_CIRCUMSTANCES.has(piece)) {
+        (condition.circumstances ??= []).push(piece);
+        continue;
+      }
+      understood = false;
+      break;
+    }
+    if (!understood) {
+      condition.unreadable = token;
+      continue;
+    }
+    if (spans.length) (condition.times ??= []).push(...spans);
+    if (days.length) (condition.days ??= []).push(...days);
+    if (months.length) (condition.months ??= []).push(...months);
+  }
+  return condition;
+}
+function parseConditional(value) {
+  if (!value || !value.includes("@")) return [];
+  const rules = [];
+  for (const part of splitOutsideBrackets(value, ";")) {
+    const at = part.indexOf("@");
+    if (at < 0) continue;
+    const left = part.slice(0, at).trim();
+    const right = part.slice(at + 1).trim();
+    if (!left || !right) continue;
+    const grouped = right.startsWith("(") && right.endsWith(")") ? right.slice(1, -1) : right;
+    const parts = splitOutsideBrackets(grouped, ";");
+    rules.push({ value: left, conditions: (parts.length ? parts : [grouped]).map(parseCondition) });
+  }
+  return rules;
+}
+var withinRange = (value, range) => range.from <= range.to ? value >= range.from && value <= range.to : value >= range.from || value <= range.to;
+var withinSpan = (minutes, span) => span.from <= span.to ? minutes >= span.from && minutes < span.to : minutes >= span.from || minutes < span.to;
+var YESTERDAY = (weekday) => (weekday + 6) % 7;
+function dayBefore(when) {
+  const rolledOver = when.dayOfMonth === 1;
+  return {
+    weekday: YESTERDAY(when.weekday),
+    month: rolledOver ? when.month === 1 ? 12 : when.month - 1 : when.month
+  };
+}
+function selects(condition, day) {
+  if (condition.days?.length && !condition.days.some((range) => withinRange(day.weekday, range))) return false;
+  if (condition.months?.length && !condition.months.some((range) => withinRange(day.month - 1, range))) return false;
+  return true;
+}
+function dayAndTimeHold(condition, when) {
+  if (!condition.times?.length) return selects(condition, when);
+  return condition.times.some((span) => {
+    if (span.from <= span.to) return selects(condition, when) && withinSpan(when.minutes, span);
+    if (when.minutes >= span.from) return selects(condition, when);
+    if (when.minutes < span.to) return selects(condition, dayBefore(when));
+    return false;
+  });
+}
+function conditionHolds(condition, when, vehicle, circumstances) {
+  if (condition.unreadable !== void 0) return false;
+  if (condition.publicHoliday && !when.publicHoliday) return false;
+  if (condition.circumstances?.length) {
+    const yes = answered(circumstances);
+    if (!condition.circumstances.every((name) => yes.has(name))) return false;
+  }
+  if (!dayAndTimeHold(condition, when)) return false;
+  if (condition.vehicle?.length) {
+    if (!vehicle) return false;
+    for (const test of condition.vehicle) {
+      const measured = test.property === "weight" ? vehicle.weightTonnes : test.property === "height" ? vehicle.heightMeters : test.property === "width" ? vehicle.widthMeters : vehicle.lengthMeters;
+      const holds = test.operator === "<" ? measured < test.amount : test.operator === "<=" ? measured <= test.amount : test.operator === ">" ? measured > test.amount : test.operator === ">=" ? measured >= test.amount : measured === test.amount;
+      if (!holds) return false;
+    }
+  }
+  return true;
+}
+function conditionalValue(rules, when, vehicle, circumstances) {
+  let effective = null;
+  for (const rule of rules) {
+    if (rule.conditions.some((condition) => conditionHolds(condition, when, vehicle, circumstances))) effective = rule.value;
+  }
+  return effective;
+}
+function unreadableConditions(rules) {
+  return rules.reduce((count, rule) => count + rule.conditions.filter((condition) => condition.unreadable !== void 0).length, 0);
+}
+var WEEKDAY_NUMBER = { Mon: 0, Tue: 1, Wed: 2, Thu: 3, Fri: 4, Sat: 5, Sun: 6 };
+function travelTimeFrom(date, publicHoliday = false, timeZone) {
+  if (!timeZone) {
+    return {
+      weekday: (date.getDay() + 6) % 7,
+      minutes: date.getHours() * 60 + date.getMinutes(),
+      month: date.getMonth() + 1,
+      dayOfMonth: date.getDate(),
+      publicHoliday
+    };
+  }
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone,
+    weekday: "short",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    hour12: false
+  }).formatToParts(date);
+  const field = (type) => parts.find((part) => part.type === type)?.value ?? "";
+  const hour = Number(field("hour")) % 24;
+  return {
+    weekday: WEEKDAY_NUMBER[field("weekday")] ?? 0,
+    minutes: hour * 60 + Number(field("minute")),
+    month: Number(field("month")),
+    dayOfMonth: Number(field("day")),
+    publicHoliday
+  };
+}
+var ConditionKind = { access: 0, maxspeed: 1 };
+function packEdgeConditions(entries) {
+  const rows = entries.filter((entry) => parseConditional(entry.value).length > 0).sort((a, b) => a.edge - b.edge || a.kind - b.kind);
+  if (!rows.length) return void 0;
+  const index = /* @__PURE__ */ new Map();
+  const values = [];
+  const kept = [];
+  for (const row of rows) {
+    let at = index.get(row.value);
+    if (at === void 0) {
+      if (values.length >= MAX_STORED_VALUES) {
+        throw new RangeError(
+          `A tile holds more than ${MAX_STORED_VALUES} distinct conditional restrictions, which is more than the stored index can name. Compile the region in smaller tiles with --tile-size-km.`
+        );
+      }
+      at = values.push(row.value) - 1;
+      index.set(row.value, at);
+    }
+    kept.push({ edge: row.edge, kind: row.kind, rule: at });
+  }
+  if (!kept.length) return void 0;
+  return {
+    edges: Uint32Array.from(kept, (row) => row.edge),
+    kinds: Uint8Array.from(kept, (row) => row.kind),
+    rules: Uint16Array.from(kept, (row) => row.rule),
+    values
+  };
+}
+function parseEdgeConditions(table) {
+  if (!table?.edges.length) return void 0;
+  return { table, parsed: table.values.map(parseConditional) };
+}
+function firstRowFor(edges, edge) {
+  let low = 0;
+  let high = edges.length - 1;
+  let found = -1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    if (edges[middle] >= edge) {
+      if (edges[middle] === edge) found = middle;
+      high = middle - 1;
+    } else low = middle + 1;
+  }
+  return found;
+}
+var CLOSED = /* @__PURE__ */ new Set(["no", "private", "destination", "customers", "delivery", "permit", "agricultural", "forestry"]);
+function conditionsOnEdge(conditions, edge, when, vehicle, circumstances) {
+  const { table, parsed } = conditions;
+  let closed = false;
+  let speedKph;
+  for (let row = firstRowFor(table.edges, edge); row >= 0 && row < table.edges.length && table.edges[row] === edge; row += 1) {
+    const value = conditionalValue(parsed[table.rules[row]], when, vehicle, circumstances);
+    if (value === null) continue;
+    if (table.kinds[row] === ConditionKind.access) {
+      if (CLOSED.has(value.trim().toLowerCase())) closed = true;
+    } else {
+      const parsedSpeed = parseMaxSpeedKph(value);
+      if (parsedSpeed !== null && parsedSpeed > 0) speedKph = speedKph === void 0 ? parsedSpeed : Math.min(speedKph, parsedSpeed);
+    }
+  }
+  return { closed, speedKph };
+}
+function accessAtTime(graph, conditions, when, vehicle, base, circumstances) {
+  const start = base ?? graph.edgeAccess;
+  if (!when || !conditions) return start;
+  const edges = graph.edgeTargets.length;
+  let mask;
+  const { table } = conditions;
+  for (let row = 0; row < table.edges.length; row += 1) {
+    const edge = table.edges[row];
+    if (edge >= edges || table.kinds[row] !== ConditionKind.access) continue;
+    if (mask && !edgeAllowed(mask, edge)) continue;
+    if (!conditionsOnEdge(conditions, edge, when, vehicle, circumstances).closed) continue;
+    mask ??= start ? Uint8Array.from(start) : accessMaskFor(edges, () => true);
+    mask[edge >> 3] &= ~(1 << (edge & 7));
+  }
+  return mask ?? start;
+}
+function countClosedAt(graph, conditions, when, vehicle) {
+  const before = graph.edgeAccess;
+  const after = accessAtTime(graph, conditions, when, vehicle);
+  if (after === before) return 0;
+  let closed = 0;
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) {
+    if (edgeAllowed(before, edge) && !edgeAllowed(after, edge)) closed += 1;
+  }
+  return closed;
+}
+var parsedByTable = /* @__PURE__ */ new WeakMap();
+function conditionsOf(graph) {
+  const table = graph.edgeConditions;
+  if (!table?.edges.length) return void 0;
+  const existing = parsedByTable.get(table);
+  if (existing) return existing;
+  const parsed = parseEdgeConditions(table);
+  parsedByTable.set(table, parsed);
+  return parsed;
+}
+function conditionalDurations(graph, conditions, when, vehicle, circumstances) {
+  if (!conditions) return void 0;
+  const distanceScale = graph.edgeDistanceScale ?? 1;
+  const durationScale = graph.edgeDurationScale ?? 1;
+  const slowed = /* @__PURE__ */ new Map();
+  const { table } = conditions;
+  for (let row = 0; row < table.edges.length; row += 1) {
+    const edge = table.edges[row];
+    if (table.kinds[row] !== ConditionKind.maxspeed || edge >= graph.edgeTargets.length || slowed.has(edge)) continue;
+    const { speedKph } = conditionsOnEdge(conditions, edge, when, vehicle, circumstances);
+    if (speedKph === void 0) continue;
+    const stored = graph.edgeDurationsSeconds[edge] * durationScale;
+    const limited = graph.edgeDistancesMeters[edge] * distanceScale / (speedKph / 3.6);
+    if (limited > stored) slowed.set(edge, limited);
+  }
+  return slowed.size ? slowed : void 0;
+}
+
+// src/routing-profile.ts
+var ProfileId = {
+  unspecified: 0,
+  car: 1,
+  truck: 2,
+  motorcycle: 3,
+  bicycle: 4,
+  pedestrian: 5
+};
+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 MOTOR_VEHICLE_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 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 BARRIER_DEFAULTS = {
+  bollard: { motor: false, bicycle: true, foot: true },
+  block: { motor: false, bicycle: true, foot: true },
+  jersey_barrier: { motor: false, bicycle: true, foot: true },
+  planter: { motor: false, bicycle: true, foot: true },
+  cycle_barrier: { motor: false, bicycle: false, foot: true },
+  stile: { motor: false, bicycle: false, foot: true },
+  turnstile: { motor: false, bicycle: false, foot: true },
+  kissing_gate: { motor: false, bicycle: false, foot: true },
+  fence: { motor: false, bicycle: false, foot: false },
+  wall: { motor: false, bicycle: false, foot: false },
+  hedge: { motor: false, bicycle: false, foot: false },
+  ditch: { motor: false, bicycle: false, foot: false },
+  // A gate or a boom is usually open, or opens for you; `access` and `locked`
+  // say when it is not.
+  gate: { motor: true, bicycle: true, foot: true },
+  lift_gate: { motor: true, bicycle: true, foot: true },
+  swing_gate: { motor: true, bicycle: true, foot: true },
+  bus_trap: { motor: false, bicycle: true, foot: true },
+  sally_port: { motor: true, bicycle: true, foot: true },
+  toll_booth: { motor: true, bicycle: true, foot: true },
+  border_control: { motor: true, bicycle: true, foot: true },
+  entrance: { motor: true, bicycle: true, foot: true }
+};
+var BARRIER_TAG_KEYS = ["barrier", "locked", "access", "foot", "bicycle", "vehicle", "motor_vehicle", "motorcar", "motorcycle", "hgv"];
+function barrierAllows(tags, accessKeys, kind) {
+  const barrier = tags.barrier?.trim().toLowerCase();
+  if (!barrier || barrier === "no") return true;
+  let decided;
+  for (const key of accessKeys) {
+    const value = tags[key];
+    if (value !== void 0) decided = !BLOCKED_ACCESS.has(value);
+  }
+  if (decided !== void 0) return decided;
+  if (tags.locked?.trim().toLowerCase() === "yes") return false;
+  const defaults = BARRIER_DEFAULTS[barrier];
+  return defaults ? defaults[kind] : true;
+}
+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));
+}
+var UNMEASURED = /* @__PURE__ */ new Set(["default", "below_default", "none", "unsigned", "no_sign", "no", "yes", "unknown"]);
+var FEET_METERS = 0.3048;
+var INCH_METERS = 0.0254;
+function parseLengthMeters(value) {
+  if (!value) return null;
+  const text = value.trim().toLowerCase();
+  if (UNMEASURED.has(text)) return null;
+  const imperial = /^(\d+(?:\.\d+)?)\s*(?:'|ft|feet)\s*(?:(\d+(?:\.\d+)?)\s*(?:"|in|inch(?:es)?)?)?$/.exec(text);
+  if (imperial) {
+    const metres = Number(imperial[1]) * FEET_METERS + Number(imperial[2] ?? 0) * INCH_METERS;
+    return metres > 0 ? metres : null;
+  }
+  const metric = /^(\d+(?:\.\d+)?)\s*(m|metres?|meters?|cm)?$/.exec(text);
+  if (!metric) return null;
+  const amount = Number(metric[1]);
+  if (!Number.isFinite(amount) || amount <= 0) return null;
+  return metric[2] === "cm" ? amount / 100 : amount;
+}
+function parseWeightTonnes(value) {
+  if (!value) return null;
+  const text = value.trim().toLowerCase();
+  if (UNMEASURED.has(text)) return null;
+  const match = /^(\d+(?:\.\d+)?)\s*(t|tonnes?|tons?|kg|lbs?|pounds?)?$/.exec(text);
+  if (!match) return null;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) return null;
+  if (match[2] === "kg") return amount / 1e3;
+  if (match[2] === "lb" || match[2] === "lbs" || match[2] === "pound" || match[2] === "pounds") return amount * 45359237e-11;
+  return amount;
+}
+var LIMIT_KEYS = [
+  ["heightMeters", "maxheight", parseLengthMeters],
+  ["widthMeters", "maxwidth", parseLengthMeters],
+  ["lengthMeters", "maxlength", parseLengthMeters],
+  ["weightTonnes", "maxweight", parseWeightTonnes]
+];
+function limitsFor(tags, mode, direction) {
+  const limits = {};
+  let found = false;
+  for (const [field, key, parse] of LIMIT_KEYS) {
+    const value = parse(tags[`${key}:${direction}`]) ?? parse(tags[`${key}:${mode}`]) ?? parse(tags[key]);
+    const physical = key === "maxheight" || key === "maxwidth" ? parse(tags[`${key}:physical`]) : null;
+    const resolved = value !== null && physical !== null ? Math.min(value, physical) : value ?? physical;
+    if (resolved !== null && resolved !== void 0) {
+      limits[field] = resolved;
+      found = true;
+    }
+  }
+  return found ? limits : void 0;
+}
+function conditionsFor(tags, accessKeys, speedKeys) {
+  const found = [];
+  let access;
+  for (const key of accessKeys) {
+    const value = tags[`${key}:conditional`];
+    if (value !== void 0) access = value;
+  }
+  if (access) found.push({ kind: ConditionKind.access, value: access });
+  let speed;
+  for (const key of speedKeys) {
+    const value = tags[`${key}:conditional`];
+    if (value !== void 0) speed = value;
+  }
+  if (speed) found.push({ kind: ConditionKind.maxspeed, value: speed });
+  return found.length ? found : void 0;
+}
+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, keys) {
+  let oneway;
+  for (const key of keys) if (tags[key] !== void 0) oneway = tags[key];
+  const value = oneway?.trim().toLowerCase();
+  if (value === "yes" || value === "true" || value === "1") return { forward: true, backward: false };
+  if (value === "-1" || value === "reverse") return { forward: false, backward: true };
+  if (value !== void 0 && value !== "") 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 };
+}
+function motorVehicleProfile(options) {
+  const { name, id, mode } = options;
+  const speeds = options.speeds ?? MOTOR_VEHICLE_SPEEDS;
+  const ceiling = options.speedCeilingKph ?? MAXIMUM_SPEED_KPH;
+  const limit = (value) => Math.min(ceiling, value);
+  const accessKeys = ["access", "vehicle", "motor_vehicle", mode];
+  const onewayKeys = ["oneway", "oneway:motor_vehicle", `oneway:${mode}`];
+  const restrictionKeys = ["restriction", "restriction:vehicle", "restriction:motor_vehicle", `restriction:${mode}`];
+  const exceptModes = /* @__PURE__ */ new Set([mode, "motor_vehicle", "vehicle"]);
+  return {
+    name,
+    id,
+    wayTagKeys: [
+      "highway",
+      "junction",
+      "maxspeed",
+      "maxspeed:forward",
+      "maxspeed:backward",
+      `maxspeed:${mode}`,
+      ...accessKeys,
+      ...onewayKeys,
+      // The conditional forms of the same keys, which the router reads against
+      // a departure time rather than the compiler against nothing.
+      ...accessKeys.map((key) => `${key}:conditional`),
+      "maxspeed:conditional",
+      `maxspeed:${mode}:conditional`,
+      ...options.physicalLimits ? LIMIT_KEYS.flatMap(([, key]) => [key, `${key}:${mode}`, `${key}:forward`, `${key}:backward`, ...key === "maxheight" || key === "maxwidth" ? [`${key}:physical`] : []]) : []
+    ],
+    relationTagKeys: ["type", "except", ...restrictionKeys, ...restrictionKeys.map((key) => `${key}:conditional`)],
+    maxSpeedKph: ceiling,
+    nodeTagKeys: BARRIER_TAG_KEYS,
+    evaluateBarrier: (tags) => barrierAllows(tags, accessKeys, "motor"),
+    ...options.physicalLimits ? { usesPhysicalLimits: true } : {},
+    evaluateWay(tags) {
+      const highway = tags.highway;
+      if (!highway || !(highway in speeds)) return null;
+      if (!accessAllowed(tags, accessKeys)) return null;
+      const { forward, backward } = onewayDirections(tags, highway, onewayKeys);
+      if (!forward && !backward) return null;
+      const base = parseMaxSpeedKph(tags[`maxspeed:${mode}`]) ?? parseMaxSpeedKph(tags.maxspeed) ?? speeds[highway];
+      return {
+        forward,
+        backward,
+        // A vehicle class with a lower legal ceiling does not reach the posted
+        // limit on a road signed above it, so the ceiling caps the speed
+        // rather than only bounding the A* heuristic.
+        forwardSpeedKph: clampSpeed(limit(parseMaxSpeedKph(tags["maxspeed:forward"]) ?? base)),
+        backwardSpeedKph: clampSpeed(limit(parseMaxSpeedKph(tags["maxspeed:backward"]) ?? base)),
+        ...options.physicalLimits ? {
+          forwardLimits: limitsFor(tags, mode, "forward"),
+          backwardLimits: limitsFor(tags, mode, "backward")
+        } : {},
+        .../* @__PURE__ */ ((conditions) => conditions ? { conditions } : {})(conditionsFor(tags, accessKeys, ["maxspeed", `maxspeed:${mode}`]))
+      };
+    },
+    evaluateTurnRestriction(tags) {
+      if (tags.type !== "restriction") return null;
+      const except = tags.except?.split(";").map((value2) => value2.trim().toLowerCase()) ?? [];
+      if (except.some((value2) => exceptModes.has(value2))) return null;
+      let value;
+      for (const key of restrictionKeys) 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 carRoutingProfile = motorVehicleProfile({ name: "car", id: ProfileId.car, mode: "motorcar" });
+var motorcycleRoutingProfile = motorVehicleProfile({ name: "motorcycle", id: ProfileId.motorcycle, mode: "motorcycle" });
+var truckRoutingProfile = motorVehicleProfile({
+  name: "truck",
+  id: ProfileId.truck,
+  mode: "hgv",
+  // Heavy vehicles are held below the posted limit nearly everywhere; 90 is
+  // at or above the cap in the regimes this library has to serve at once.
+  speedCeilingKph: 90,
+  physicalLimits: true
+});
+var WALKING_SPEEDS = {
+  footway: 5,
+  // A shared path is often tagged as a cycleway; where walking is genuinely
+  // forbidden, `foot=no` says so and the access ladder catches it.
+  cycleway: 5,
+  path: 5,
+  pedestrian: 5,
+  living_street: 5,
+  residential: 5,
+  service: 5,
+  unclassified: 5,
+  road: 5,
+  tertiary: 5,
+  tertiary_link: 5,
+  secondary: 5,
+  secondary_link: 5,
+  primary: 5,
+  primary_link: 5,
+  track: 4,
+  bridleway: 4,
+  corridor: 5,
+  steps: 2
+};
+var CYCLING_SPEEDS = {
+  cycleway: 18,
+  residential: 15,
+  living_street: 10,
+  service: 12,
+  unclassified: 15,
+  road: 14,
+  tertiary: 16,
+  tertiary_link: 14,
+  secondary: 16,
+  secondary_link: 14,
+  primary: 15,
+  primary_link: 13,
+  path: 11,
+  footway: 7,
+  pedestrian: 7,
+  track: 9,
+  bridleway: 8
+};
+function activeTravelProfile(options) {
+  const { name, id, mode, speeds, ceilingKph, accessKeys, ignoresOneway, floorKph } = options;
+  const onewayKeys = [`oneway:${mode}`];
+  const restrictionKeys = ["restriction", `restriction:${mode}`];
+  const exceptModes = /* @__PURE__ */ new Set([mode]);
+  return {
+    name,
+    id,
+    wayTagKeys: [
+      "highway",
+      "junction",
+      "maxspeed",
+      ...accessKeys,
+      "oneway",
+      ...onewayKeys,
+      ...accessKeys.map((key) => `${key}:conditional`)
+    ],
+    relationTagKeys: ["type", "except", ...restrictionKeys, ...restrictionKeys.map((key) => `${key}:conditional`)],
+    maxSpeedKph: ceilingKph,
+    nodeTagKeys: BARRIER_TAG_KEYS,
+    evaluateBarrier: (tags) => barrierAllows(tags, accessKeys, mode === "foot" ? "foot" : "bicycle"),
+    evaluateWay(tags) {
+      const highway = tags.highway;
+      if (!highway || !(highway in speeds)) return null;
+      if (!accessAllowed(tags, accessKeys)) return null;
+      const own = tags[`oneway:${mode}`]?.trim().toLowerCase();
+      let forward = true;
+      let backward = true;
+      if (own !== void 0 && own !== "") {
+        forward = own !== "-1" && own !== "reverse";
+        backward = own === "no" || own === "false" || own === "0" || own === "-1" || own === "reverse";
+      } else if (!ignoresOneway) {
+        ({ forward, backward } = onewayDirections(tags, highway, ["oneway"]));
+      }
+      if (!forward && !backward) return null;
+      const posted = parseMaxSpeedKph(tags.maxspeed);
+      const wanted = Math.min(speeds[highway], posted !== null && posted > 0 ? posted : Infinity);
+      const speed = Math.min(ceilingKph, Math.max(floorKph, wanted));
+      const conditions = conditionsFor(tags, accessKeys, []);
+      return { forward, backward, forwardSpeedKph: speed, backwardSpeedKph: speed, ...conditions ? { conditions } : {} };
+    },
+    evaluateTurnRestriction(tags) {
+      if (tags.type !== "restriction") return null;
+      const except = tags.except?.split(";").map((value2) => value2.trim().toLowerCase()) ?? [];
+      if (except.some((value2) => exceptModes.has(value2))) return null;
+      let value;
+      for (const key of restrictionKeys) 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 bicycleRoutingProfile = activeTravelProfile({
+  name: "bicycle",
+  id: ProfileId.bicycle,
+  mode: "bicycle",
+  speeds: CYCLING_SPEEDS,
+  ceilingKph: 30,
+  accessKeys: ["access", "vehicle", "bicycle"],
+  ignoresOneway: false,
+  floorKph: 4
+});
+var pedestrianRoutingProfile = activeTravelProfile({
+  name: "pedestrian",
+  id: ProfileId.pedestrian,
+  mode: "foot",
+  speeds: WALKING_SPEEDS,
+  ceilingKph: 7,
+  accessKeys: ["access", "foot"],
+  ignoresOneway: true,
+  floorKph: 1
+});
+var routingProfiles = {
+  car: carRoutingProfile,
+  motorcycle: motorcycleRoutingProfile,
+  truck: truckRoutingProfile,
+  bicycle: bicycleRoutingProfile,
+  pedestrian: pedestrianRoutingProfile
+};
+function getRoutingProfile(name) {
+  const profile = routingProfiles[name];
+  if (!profile) throw new Error(`Unknown routing profile "${name}". Available: ${Object.keys(routingProfiles).join(", ")}.`);
+  return profile;
+}
+function getRoutingProfileById(id) {
+  if (id === ProfileId.unspecified) return carRoutingProfile;
+  return Object.values(routingProfiles).find((profile) => profile.id === id) ?? null;
+}
+function profileOf(graph) {
+  return getRoutingProfileById(graph.profileId ?? ProfileId.unspecified) ?? carRoutingProfile;
+}
+function maxSpeedMpsFor(graph) {
+  return (graph.maxSpeedKph ?? profileOf(graph).maxSpeedKph) * 1e3 / 3600;
+}
+
+// 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, 7]);
+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.profileId) throw new Error("The legacy EFR2 layout cannot store a routing profile. Use the packed layout.");
+  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);
+  if (version === SPLIT_COMPACT_VERSION) {
+    throw new Error(view.getUint8(6) === ChunkKind.profile ? "This is a routing profile chunk; it has to be combined with the shared chunk it belongs to." : "This routing graph stores several profiles; load it with a profile chunk rather than on its own.");
+  }
+  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 SPLIT_COMPACT_VERSION = 7;
+var ChunkKind = { shared: 0, profile: 1 };
+var PACKED_HEADER_BYTES = 64;
+var MAX_PLAUSIBLE_SPEED_KPH = 400;
+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 encodeSharedGraph(graph) {
+  return encodePackedGraph(graph, SPLIT_COMPACT_VERSION);
+}
+function assertEdgeConditions(conditions, edges) {
+  const rows = conditions.edges.length;
+  if (conditions.kinds.length !== rows || conditions.rules.length !== rows) throw new Error("Edge condition columns must all be the same length.");
+  for (let index = 0; index < rows; index += 1) {
+    if (conditions.edges[index] >= edges) throw new Error("Edge condition references an edge outside the graph.");
+    if (index && conditions.edges[index] < conditions.edges[index - 1]) throw new Error("Edge conditions must be sorted by edge.");
+    if (conditions.rules[index] >= conditions.values.length) throw new Error("Edge condition names a value that is not in the table.");
+  }
+  if (conditions.values.some((value) => value.includes("\0"))) throw new Error("A conditional value cannot contain a null byte.");
+}
+function readEdgeConditions(buffer, at, edges) {
+  const view = new DataView(buffer);
+  const rows = view.getUint32(at, true);
+  const textBytes = view.getUint32(at + 4, true);
+  const conditionEdges = new Uint32Array(buffer.slice(at + 8, at + 8 + rows * 4));
+  for (let index = 0; index < rows; index += 1) {
+    if (conditionEdges[index] >= edges) throw new Error("Invalid routing graph: condition references an edge outside the graph.");
+    if (index && conditionEdges[index] < conditionEdges[index - 1]) throw new Error("Invalid routing graph: conditions are not sorted.");
+  }
+  const values = new TextDecoder().decode(new Uint8Array(buffer, alignUp(at + 8 + rows * 7), textBytes)).split("\0");
+  const rules = new Uint16Array(buffer.slice(at + 8 + rows * 4, at + 8 + rows * 6));
+  for (let index = 0; index < rows; index += 1) {
+    if (rules[index] >= values.length) throw new Error("Invalid routing graph: condition names a value that is not in the table.");
+  }
+  return { edges: conditionEdges, rules, kinds: new Uint8Array(buffer.slice(at + 8 + rows * 6, at + 8 + rows * 7)), values };
+}
+function encodePackedGraph(graph, version = PACKED_COMPACT_VERSION) {
+  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 shared = version === SPLIT_COMPACT_VERSION;
+  const coordinates = new VarintWriter(nodes * 4 + 16);
+  if (shared) {
+    let previous = 0;
+    for (let node = 0; node < nodes; node += 1) {
+      coordinates.pushSigned(graph.nodeLatitudes[node] - previous);
+      previous = graph.nodeLatitudes[node];
+    }
+    previous = 0;
+    for (let node = 0; node < nodes; node += 1) {
+      coordinates.pushSigned(graph.nodeLongitudes[node] - previous);
+      previous = graph.nodeLongitudes[node];
+    }
+  }
+  const sections = shared ? [coordinates, degrees, targets, shapeRefs, shapeSizes, shapePoints] : [degrees, targets, shapeRefs, shapeSizes, shapePoints];
+  const variableBytes = sections.reduce((sum, section) => sum + section.byteLength, 0);
+  const weightBytes = edges * (shared ? 2 : 4);
+  const restrictionsAt = alignUp(PACKED_HEADER_BYTES + (shared ? 0 : nodes * 8) + weightBytes + variableBytes);
+  const restrictionsEnd = restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0);
+  const conditions = !shared && graph.edgeConditions?.edges.length ? graph.edgeConditions : void 0;
+  if (conditions) assertEdgeConditions(conditions, edges);
+  const conditionRows = conditions?.edges.length ?? 0;
+  const conditionText = conditions ? new TextEncoder().encode(conditions.values.join("\0")) : void 0;
+  const conditionsAt = alignUp(restrictionsEnd);
+  const conditionTextAt = alignUp(conditionsAt + 8 + conditionRows * 7);
+  const buffer = new ArrayBuffer(conditionRows ? conditionTextAt + (conditionText?.byteLength ?? 0) : restrictionsEnd);
+  const view = new DataView(buffer);
+  view.setUint32(0, COMPACT_MAGIC, true);
+  view.setUint16(4, version, true);
+  view.setUint8(6, shared ? ChunkKind.shared : ChunkKind.profile);
+  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);
+  if (!shared) {
+    view.setUint8(60, graph.profileId ?? 0);
+    view.setUint8(61, conditionRows ? 1 : 0);
+    view.setUint16(62, Math.round(graph.maxSpeedKph ?? 0), true);
+  }
+  let offset = PACKED_HEADER_BYTES;
+  if (!shared) {
+    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;
+  if (!shared) {
+    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);
+  }
+  if (conditions && conditionRows && conditionText) {
+    view.setUint32(conditionsAt, conditionRows, true);
+    view.setUint32(conditionsAt + 4, conditionText.byteLength, true);
+    new Uint32Array(buffer, conditionsAt + 8, conditionRows).set(conditions.edges);
+    new Uint16Array(buffer, conditionsAt + 8 + conditionRows * 4, conditionRows).set(conditions.rules);
+    new Uint8Array(buffer, conditionsAt + 8 + conditionRows * 6, conditionRows).set(conditions.kinds);
+    new Uint8Array(buffer, conditionTextAt, conditionText.byteLength).set(conditionText);
+  }
+  return buffer;
+}
+function decodePackedGraph(buffer, shared = false) {
+  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: shared ? 6 : 5 }, (_, index) => view.getUint32(40 + index * 4, true));
+  const variableBytes = lengths.reduce((sum, length) => sum + length, 0);
+  const restrictionsAt = alignUp(PACKED_HEADER_BYTES + (shared ? 0 : nodes * 8) + edges * (shared ? 2 : 4) + variableBytes);
+  const restrictionsEnd = restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0);
+  const hasConditions = !shared && view.getUint8(61) === 1;
+  const conditionsAt = alignUp(restrictionsEnd);
+  let expected = restrictionsEnd;
+  if (hasConditions) {
+    if (buffer.byteLength < conditionsAt + 8) throw new Error("Truncated compact routing graph");
+    const rows = view.getUint32(conditionsAt, true);
+    const textBytes = view.getUint32(conditionsAt + 4, true);
+    if (rows > edges || !textBytes) throw new Error("Invalid compact routing graph: conditions do not fit the graph.");
+    expected = alignUp(conditionsAt + 8 + rows * 7) + textBytes;
+  }
+  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.");
+  const profileId = shared ? 0 : view.getUint8(60);
+  const maxSpeedKph = shared ? 0 : view.getUint16(62, true);
+  if (profileId && !getRoutingProfileById(profileId)) throw new Error(`Routing graph was compiled for an unsupported profile (id ${profileId}).`);
+  if (maxSpeedKph > MAX_PLAUSIBLE_SPEED_KPH) throw new Error("Invalid compact routing graph: implausible profile speed ceiling.");
+  let offset = PACKED_HEADER_BYTES;
+  const nodeLatitudes = new Int32Array(nodes);
+  const nodeLongitudes = new Int32Array(nodes);
+  if (!shared) {
+    nodeLatitudes.set(new Int32Array(buffer.slice(offset, offset += nodes * 4)));
+    nodeLongitudes.set(new Int32Array(buffer.slice(offset, offset += nodes * 4)));
+  }
+  const edgeDistancesMeters = new Uint16Array(buffer.slice(offset, offset += edges * 2));
+  const edgeDurationsSeconds = shared ? new Uint16Array(edges) : 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;
+  if (shared) {
+    const reader = new VarintReader(bytes, starts[0]);
+    let previous = 0;
+    for (let node = 0; node < nodes; node += 1) {
+      previous += reader.readSigned();
+      nodeLatitudes[node] = previous;
+    }
+    previous = 0;
+    for (let node = 0; node < nodes; node += 1) {
+      previous += reader.readSigned();
+      nodeLongitudes[node] = previous;
+    }
+    starts.shift();
+  }
+  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 };
+  if (profileId) graph.profileId = profileId;
+  if (maxSpeedKph) graph.maxSpeedKph = maxSpeedKph;
+  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[lengths.length - 1] / 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.");
+  if (hasConditions) graph.edgeConditions = readEdgeConditions(buffer, conditionsAt, edges);
+  return graph;
+}
+var PROFILE_CHUNK_HEADER_BYTES = 64;
+function encodeProfileChunk(chunk) {
+  const edges = chunk.edgeDurationsSeconds.length;
+  const limits = chunk.edgeLimits?.edges.length ? chunk.edgeLimits : void 0;
+  if (limits) {
+    const rows = limits.edges.length;
+    if (limits.heightDecimetres.length !== rows || limits.widthDecimetres.length !== rows || limits.lengthDecimetres.length !== rows || limits.weightHalfTonnes.length !== rows) {
+      throw new Error("Edge limit columns must all be the same length.");
+    }
+    for (let index = 0; index < rows; index += 1) {
+      if (limits.edges[index] >= edges) throw new Error("Edge limit references an edge outside the graph.");
+      if (index && limits.edges[index] <= limits.edges[index - 1]) throw new Error("Edge limits must be sorted and unique.");
+    }
+  }
+  if (!(chunk.edgeDurationsSeconds instanceof Uint16Array)) throw new Error("Profile durations must be a Uint16Array.");
+  if (!Number.isInteger(chunk.edgeDurationScale) || chunk.edgeDurationScale <= 0 || chunk.edgeDurationScale > 65535) throw new Error("Invalid profile duration scale.");
+  if (!getRoutingProfileById(chunk.profileId) || !chunk.profileId) throw new Error(`Cannot write a profile chunk for an unsupported profile (id ${chunk.profileId}).`);
+  if (chunk.maxSpeedKph <= 0 || chunk.maxSpeedKph > MAX_PLAUSIBLE_SPEED_KPH) throw new Error("Invalid profile speed ceiling.");
+  const mask = chunk.edgeAccess && !allowsEverything(chunk.edgeAccess, edges) ? chunk.edgeAccess : void 0;
+  if (mask && mask.length !== edges + 7 >> 3) throw new Error("Profile access mask does not cover every edge.");
+  const restrictions = chunk.restrictionCount ?? 0;
+  const turns = chunk.restrictionMask && restrictions && !allowsEverything(chunk.restrictionMask, restrictions) ? chunk.restrictionMask : void 0;
+  if (turns && turns.length !== restrictions + 7 >> 3) throw new Error("Profile restriction mask does not cover every restriction.");
+  const variableAt = PROFILE_CHUNK_HEADER_BYTES + edges * 2 + (mask?.byteLength ?? 0) + (turns?.byteLength ?? 0);
+  const limitsAt = alignUp(variableAt);
+  const limitRows = limits?.edges.length ?? 0;
+  const limitsEnd = limitRows ? limitsAt + limitRows * 8 : variableAt;
+  const conditions = chunk.edgeConditions?.edges.length ? chunk.edgeConditions : void 0;
+  if (conditions) assertEdgeConditions(conditions, edges);
+  const conditionRows = conditions?.edges.length ?? 0;
+  const conditionText = conditions ? new TextEncoder().encode(conditions.values.join("\0")) : void 0;
+  const conditionsAt = alignUp(limitsEnd);
+  const conditionTextAt = alignUp(conditionsAt + conditionRows * 7);
+  const buffer = new ArrayBuffer(conditionRows ? conditionTextAt + (conditionText?.byteLength ?? 0) : limitsEnd);
+  const view = new DataView(buffer);
+  view.setUint32(0, COMPACT_MAGIC, true);
+  view.setUint16(4, SPLIT_COMPACT_VERSION, true);
+  view.setUint8(6, ChunkKind.profile);
+  view.setUint8(7, chunk.profileId);
+  view.setUint32(8, edges, true);
+  view.setUint32(12, mask?.byteLength ?? 0, true);
+  view.setUint16(16, chunk.edgeDurationScale, true);
+  view.setUint16(18, Math.round(chunk.maxSpeedKph), true);
+  view.setUint32(20, limitRows, true);
+  view.setUint32(24, restrictions, true);
+  view.setUint32(28, turns?.byteLength ?? 0, true);
+  view.setUint32(32, conditionRows, true);
+  view.setUint32(36, conditionText?.byteLength ?? 0, true);
+  new Uint16Array(buffer, PROFILE_CHUNK_HEADER_BYTES, edges).set(chunk.edgeDurationsSeconds);
+  if (mask) new Uint8Array(buffer, PROFILE_CHUNK_HEADER_BYTES + edges * 2, mask.byteLength).set(mask);
+  if (turns) new Uint8Array(buffer, PROFILE_CHUNK_HEADER_BYTES + edges * 2 + (mask?.byteLength ?? 0), turns.byteLength).set(turns);
+  if (limits && limitRows) {
+    new Uint32Array(buffer, limitsAt, limitRows).set(limits.edges);
+    const columns = new Uint8Array(buffer, limitsAt + limitRows * 4, limitRows * 4);
+    columns.set(limits.heightDecimetres, 0);
+    columns.set(limits.widthDecimetres, limitRows);
+    columns.set(limits.lengthDecimetres, limitRows * 2);
+    columns.set(limits.weightHalfTonnes, limitRows * 3);
+  }
+  if (conditions && conditionRows && conditionText) {
+    new Uint32Array(buffer, conditionsAt, conditionRows).set(conditions.edges);
+    new Uint16Array(buffer, conditionsAt + conditionRows * 4, conditionRows).set(conditions.rules);
+    new Uint8Array(buffer, conditionsAt + conditionRows * 6, conditionRows).set(conditions.kinds);
+    new Uint8Array(buffer, conditionTextAt, conditionText.byteLength).set(conditionText);
+  }
+  return buffer;
+}
+function decodeProfileChunk(buffer) {
+  if (buffer.byteLength < PROFILE_CHUNK_HEADER_BYTES) throw new Error("Invalid routing profile chunk header");
+  const view = new DataView(buffer);
+  if (view.getUint32(0, true) !== COMPACT_MAGIC || view.getUint16(4, true) !== SPLIT_COMPACT_VERSION || view.getUint8(6) !== ChunkKind.profile) {
+    throw new Error("Unsupported routing profile chunk format");
+  }
+  const profileId = view.getUint8(7);
+  const edges = view.getUint32(8, true);
+  const maskBytes = view.getUint32(12, true);
+  const edgeDurationScale = view.getUint16(16, true);
+  const maxSpeedKph = view.getUint16(18, true);
+  const limitRows = view.getUint32(20, true);
+  const restrictionCount = view.getUint32(24, true);
+  const turnMaskBytes = view.getUint32(28, true);
+  const conditionRows = view.getUint32(32, true);
+  const conditionTextBytes = view.getUint32(36, true);
+  if (!profileId || !getRoutingProfileById(profileId)) throw new Error(`Routing graph was compiled for an unsupported profile (id ${profileId}).`);
+  if (!edgeDurationScale) throw new Error("Invalid routing profile chunk: zero duration scale.");
+  if (maxSpeedKph > MAX_PLAUSIBLE_SPEED_KPH) throw new Error("Invalid routing profile chunk: implausible profile speed ceiling.");
+  if (maskBytes && maskBytes !== edges + 7 >> 3) throw new Error("Invalid routing profile chunk: access mask does not cover every edge.");
+  if (turnMaskBytes && turnMaskBytes !== restrictionCount + 7 >> 3) throw new Error("Invalid routing profile chunk: restriction mask does not cover every restriction.");
+  const variableAt = PROFILE_CHUNK_HEADER_BYTES + edges * 2 + maskBytes + turnMaskBytes;
+  const limitsAt = alignUp(variableAt);
+  const limitsEnd = limitRows ? limitsAt + limitRows * 8 : variableAt;
+  const conditionsAt = alignUp(limitsEnd);
+  const conditionTextAt = alignUp(conditionsAt + conditionRows * 7);
+  const expected = conditionRows ? conditionTextAt + conditionTextBytes : limitsEnd;
+  if (limitRows > edges) throw new Error("Invalid routing profile chunk: more limits than edges.");
+  if (conditionRows && !conditionTextBytes) throw new Error("Invalid routing profile chunk: conditions with no values.");
+  if (buffer.byteLength !== expected) throw new Error("Truncated routing profile chunk");
+  let edgeLimits;
+  if (limitRows) {
+    const edgeIds = new Uint32Array(buffer.slice(limitsAt, limitsAt + limitRows * 4));
+    for (let index = 0; index < limitRows; index += 1) {
+      if (edgeIds[index] >= edges) throw new Error("Invalid routing profile chunk: limit references an edge outside the graph.");
+      if (index && edgeIds[index] <= edgeIds[index - 1]) throw new Error("Invalid routing profile chunk: limits are not sorted.");
+    }
+    const columns = new Uint8Array(buffer, limitsAt + limitRows * 4, limitRows * 4);
+    edgeLimits = {
+      edges: edgeIds,
+      heightDecimetres: columns.slice(0, limitRows),
+      widthDecimetres: columns.slice(limitRows, limitRows * 2),
+      lengthDecimetres: columns.slice(limitRows * 2, limitRows * 3),
+      weightHalfTonnes: columns.slice(limitRows * 3)
+    };
+  }
+  let edgeConditions;
+  if (conditionRows) {
+    const conditionEdges = new Uint32Array(buffer.slice(conditionsAt, conditionsAt + conditionRows * 4));
+    for (let index = 0; index < conditionRows; index += 1) {
+      if (conditionEdges[index] >= edges) throw new Error("Invalid routing profile chunk: condition references an edge outside the graph.");
+      if (index && conditionEdges[index] < conditionEdges[index - 1]) throw new Error("Invalid routing profile chunk: conditions are not sorted.");
+    }
+    const values = new TextDecoder().decode(new Uint8Array(buffer, conditionTextAt, conditionTextBytes)).split("\0");
+    const rules = new Uint16Array(buffer.slice(conditionsAt + conditionRows * 4, conditionsAt + conditionRows * 6));
+    for (let index = 0; index < conditionRows; index += 1) {
+      if (rules[index] >= values.length) throw new Error("Invalid routing profile chunk: condition names a value that is not in the table.");
+    }
+    edgeConditions = {
+      edges: conditionEdges,
+      rules,
+      kinds: new Uint8Array(buffer.slice(conditionsAt + conditionRows * 6, conditionsAt + conditionRows * 7)),
+      values
+    };
+  }
+  return {
+    profileId,
+    maxSpeedKph,
+    edgeDurationScale,
+    edgeDurationsSeconds: new Uint16Array(buffer.slice(PROFILE_CHUNK_HEADER_BYTES, PROFILE_CHUNK_HEADER_BYTES + edges * 2)),
+    ...maskBytes ? { edgeAccess: new Uint8Array(buffer.slice(PROFILE_CHUNK_HEADER_BYTES + edges * 2, PROFILE_CHUNK_HEADER_BYTES + edges * 2 + maskBytes)) } : {},
+    ...restrictionCount ? { restrictionCount } : {},
+    ...turnMaskBytes ? { restrictionMask: new Uint8Array(buffer.slice(PROFILE_CHUNK_HEADER_BYTES + edges * 2 + maskBytes, variableAt)) } : {},
+    ...edgeLimits ? { edgeLimits } : {},
+    ...edgeConditions ? { edgeConditions } : {}
+  };
+}
+function decodeSharedGraph(buffer) {
+  if (buffer.byteLength < PACKED_HEADER_BYTES) throw new Error("Invalid shared routing graph header");
+  const view = new DataView(buffer);
+  if (view.getUint32(0, true) !== COMPACT_MAGIC || view.getUint16(4, true) !== SPLIT_COMPACT_VERSION || view.getUint8(6) !== ChunkKind.shared) {
+    throw new Error("Unsupported shared routing graph format");
+  }
+  const { edgeDurationsSeconds: _durations, edgeDurationScale: _scale, profileId: _profile, maxSpeedKph: _speed, ...shared } = decodePackedGraph(buffer, true);
+  return shared;
+}
+function combineProfiledGraph(shared, profile) {
+  if (profile.edgeDurationsSeconds.length !== shared.edgeTargets.length) {
+    throw new Error("Routing profile chunk does not match the shared chunk it was loaded with.");
+  }
+  return {
+    ...shared,
+    edgeDurationsSeconds: profile.edgeDurationsSeconds,
+    edgeDurationScale: profile.edgeDurationScale,
+    profileId: profile.profileId,
+    maxSpeedKph: profile.maxSpeedKph,
+    ...profile.edgeAccess ? { edgeAccess: profile.edgeAccess } : {},
+    ...profile.edgeLimits ? { edgeLimits: profile.edgeLimits } : {},
+    ...profile.edgeConditions ? { edgeConditions: profile.edgeConditions } : {},
+    ...profile.restrictionMask ? { restrictionMask: profile.restrictionMask } : {}
+  };
+}
+
+// src/search-bounds.ts
+var RADIANS = Math.PI / 180;
+var METRES_PER_DEGREE_LATITUDE = 110574;
+var METRES_PER_DEGREE_LONGITUDE = 111320;
+var SAFETY = 0.999;
+var cache = /* @__PURE__ */ new WeakMap();
+function searchBoundsFor(graph) {
+  const held = cache.get(graph);
+  if (held) return held;
+  const distanceScale = graph.edgeDistanceScale ?? 1;
+  const durationScale = graph.edgeDurationScale ?? 1;
+  let fastest = 0;
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) {
+    const seconds = graph.edgeDurationsSeconds[edge] * durationScale;
+    if (seconds <= 0) continue;
+    const speed = graph.edgeDistancesMeters[edge] * distanceScale / seconds;
+    if (speed > fastest) fastest = speed;
+  }
+  const coordinateScale = graph.coordinateScale ?? 1;
+  let highest = 0;
+  for (let node = 0; node < graph.nodeLatitudes.length; node += 1) {
+    const latitude = Math.abs(graph.nodeLatitudes[node] / coordinateScale);
+    if (latitude > highest) highest = latitude;
+  }
+  const bounds = {
+    // An empty or zero-duration graph falls back to the profile's ceiling.
+    maxSpeedMps: Math.max(fastest, maxSpeedMpsFor(graph)),
+    longitudeMetresPerDegree: METRES_PER_DEGREE_LONGITUDE * Math.cos(Math.min(highest, 89.9) * RADIANS) * SAFETY
+  };
+  cache.set(graph, bounds);
+  return bounds;
+}
+function straightLineAtMost(latitudeA, longitudeA, latitudeB, longitudeB, longitudeMetresPerDegree) {
+  const north = (latitudeA - latitudeB) * METRES_PER_DEGREE_LATITUDE * SAFETY;
+  const east = (longitudeA - longitudeB) * longitudeMetresPerDegree;
+  return Math.sqrt(north * north + east * east);
+}
+
+// src/connectivity.ts
+var cache2 = /* @__PURE__ */ new WeakMap();
+function componentsFor(graph) {
+  const held = cache2.get(graph);
+  if (held) return held;
+  const nodes = graph.nodeLatitudes.length;
+  const labels = new Int32Array(nodes).fill(-1);
+  const incomingStart = new Uint32Array(nodes + 1);
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) incomingStart[graph.edgeTargets[edge] + 1] += 1;
+  for (let node = 1; node <= nodes; node += 1) incomingStart[node] += incomingStart[node - 1];
+  const cursor = incomingStart.slice(0, nodes);
+  const incoming = new Uint32Array(graph.edgeTargets.length);
+  for (let node = 0; node < nodes; node += 1) {
+    for (let edge = graph.edgeOffsets[node]; edge < graph.edgeOffsets[node + 1]; edge += 1) incoming[cursor[graph.edgeTargets[edge]]++] = node;
+  }
+  const stack = new Int32Array(nodes);
+  let label = 0;
+  for (let start = 0; start < nodes; start += 1) {
+    if (labels[start] !== -1) continue;
+    let top = 0;
+    stack[top++] = start;
+    labels[start] = label;
+    while (top > 0) {
+      const node = stack[--top];
+      for (let edge = graph.edgeOffsets[node]; edge < graph.edgeOffsets[node + 1]; edge += 1) {
+        const next = graph.edgeTargets[edge];
+        if (labels[next] === -1) {
+          labels[next] = label;
+          stack[top++] = next;
+        }
+      }
+      for (let slot = incomingStart[node]; slot < incomingStart[node + 1]; slot += 1) {
+        const previous = incoming[slot];
+        if (labels[previous] === -1) {
+          labels[previous] = label;
+          stack[top++] = previous;
+        }
+      }
+    }
+    label += 1;
+  }
+  cache2.set(graph, labels);
+  return labels;
+}
+function componentSizes(labels) {
+  const sizes = /* @__PURE__ */ new Map();
+  for (let node = 0; node < labels.length; node += 1) sizes.set(labels[node], (sizes.get(labels[node]) ?? 0) + 1);
+  return sizes;
+}
+
+// src/edge-index.ts
+var MAX_CELLS_PER_EDGE = 4096;
+function cellKey(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 = cellKey(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(cellKey(latitudeCell, longitudeCell));
+      if (bucket) for (const id of bucket) ids.add(id);
+    }
+  }
+  return ids;
+}
+
+// src/spatial-index.ts
+function cellKey2(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 = cellKey2(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/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;
+var DEFAULT_SNAP_RADIUS_METERS = 500;
+var FALLBACK_SNAP_RADIUS_METERS = 1e3;
+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 = DEFAULT_SNAP_RADIUS_METERS, access = graph.edgeAccess, accept, everyNearbyRoad = false) {
+  const candidates = graph.edgeTargets.length ? nearbyEdgeIds(edgeSpatialIndexFor(graph), coordinate, maxDistanceMeters) : /* @__PURE__ */ new Set();
+  let best = null;
+  const projections = [];
+  for (const edge of candidates) {
+    if (!edgeAllowed(access, edge)) continue;
+    const source = edgeSource(graph, edge);
+    if (accept && !(accept(source) && accept(graph.edgeTargets[edge]))) continue;
+    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, accept);
+    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 (!everyNearbyRoad && startMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.source, point: best.polyline[0], distanceMeters: best.distanceMeters };
+  if (!everyNearbyRoad && endMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.target, point: best.polyline[best.polyline.length - 1], distanceMeters: best.distanceMeters };
+  const sameRoad = everyNearbyRoad ? projections.sort((left, right) => left.distanceMeters - right.distanceMeters) : 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, accept) {
+  let closest = null;
+  let closestDistance = maxDistanceMeters;
+  const check2 = (nodeId) => {
+    if (accept && !accept(nodeId)) return;
+    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)) check2(nodeId);
+  else for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) check2(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/avoid.ts
+function check(area, index) {
+  const say = (what) => {
+    throw new RangeError(`avoid[${index}]: ${what}`);
+  };
+  if (!Number.isFinite(area.lat) || area.lat < -90 || area.lat > 90) say(`lat must be a latitude, not ${area.lat}.`);
+  if (!Number.isFinite(area.lng) || area.lng < -180 || area.lng > 180) say(`lng must be a longitude, not ${area.lng}.`);
+  if (!Number.isFinite(area.radiusMeters) || area.radiusMeters <= 0) say(`radiusMeters must be a positive distance, not ${area.radiusMeters}.`);
+}
+var METRES_PER_DEGREE_LATITUDE2 = 111320;
+function touchesArea(graph, edge, area, centre = { lat: area.lat, lng: area.lng }) {
+  const polyline = edgePolyline(graph, edge, edgeSource(graph, edge));
+  const longitudeScale = METRES_PER_DEGREE_LATITUDE2 * Math.cos(centre.lat * Math.PI / 180);
+  const apart = (from, to) => {
+    const delta = from - to;
+    return delta > 180 ? delta - 360 : delta < -180 ? delta + 360 : delta;
+  };
+  const x = (point) => apart(point.lng, centre.lng) * longitudeScale;
+  const y = (point) => (point.lat - centre.lat) * METRES_PER_DEGREE_LATITUDE2;
+  for (let index = 0; index < polyline.length; index += 1) {
+    if (haversineMeters(centre, polyline[index]) <= area.radiusMeters) return true;
+    if (index === 0) continue;
+    const ax = x(polyline[index - 1]);
+    const ay = y(polyline[index - 1]);
+    const bx = x(polyline[index]);
+    const by = y(polyline[index]);
+    const dx = bx - ax;
+    const dy = by - ay;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared === 0) continue;
+    const along = Math.max(0, Math.min(1, -(ax * dx + ay * dy) / lengthSquared));
+    if (Math.hypot(ax + along * dx, ay + along * dy) <= area.radiusMeters) return true;
+  }
+  return false;
+}
+function accessAvoiding(graph, areas, base) {
+  const start = base ?? graph.edgeAccess;
+  if (!areas?.length) return start;
+  areas.forEach(check);
+  const edges = graph.edgeTargets.length;
+  let mask;
+  const index = edgeSpatialIndexFor(graph);
+  for (const area of areas) {
+    const centre = { lat: area.lat, lng: area.lng };
+    for (const edge of nearbyEdgeIds(index, centre, area.radiusMeters)) {
+      if (edge >= edges) continue;
+      if (mask && !edgeAllowed(mask, edge)) continue;
+      if (!touchesArea(graph, edge, area, centre)) continue;
+      mask ??= start ? Uint8Array.from(start) : accessMaskFor(edges, () => true);
+      mask[edge >> 3] &= ~(1 << (edge & 7));
+    }
+  }
+  return mask ?? start;
+}
+function countAvoided(graph, areas) {
+  const before = graph.edgeAccess;
+  const after = accessAvoiding(graph, areas);
+  if (after === before) return 0;
+  let closed = 0;
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) {
+    if (edgeAllowed(before, edge) && !edgeAllowed(after, edge)) closed += 1;
+  }
+  return closed;
+}
+
+// src/limits.ts
+var DECIMETRE_CEILING = 255;
+var HALF_TONNE_CEILING = 255;
+function toDecimetres(metres) {
+  if (metres === void 0 || !(metres > 0)) return 0;
+  const value = Math.floor(metres * 10);
+  return value > DECIMETRE_CEILING ? 0 : value;
+}
+function toHalfTonnes(tonnes) {
+  if (tonnes === void 0 || !(tonnes > 0)) return 0;
+  const value = Math.floor(tonnes * 2);
+  return value > HALF_TONNE_CEILING ? 0 : value;
+}
+var fromDecimetres = (value) => value / 10;
+var fromHalfTonnes = (value) => value / 2;
+function packEdgeLimits(entries) {
+  const rows = entries.map(({ edge, limits }) => ({
+    edge,
+    height: toDecimetres(limits.heightMeters),
+    width: toDecimetres(limits.widthMeters),
+    length: toDecimetres(limits.lengthMeters),
+    weight: toHalfTonnes(limits.weightTonnes)
+  })).filter((row) => row.height || row.width || row.length || row.weight).sort((a, b) => a.edge - b.edge);
+  if (!rows.length) return void 0;
+  return {
+    edges: Uint32Array.from(rows, (row) => row.edge),
+    heightDecimetres: Uint8Array.from(rows, (row) => row.height),
+    widthDecimetres: Uint8Array.from(rows, (row) => row.width),
+    lengthDecimetres: Uint8Array.from(rows, (row) => row.length),
+    weightHalfTonnes: Uint8Array.from(rows, (row) => row.weight)
+  };
+}
+function blocks(limits, index, vehicle) {
+  const height = limits.heightDecimetres[index];
+  if (height && vehicle.heightMeters > fromDecimetres(height)) return true;
+  const width = limits.widthDecimetres[index];
+  if (width && vehicle.widthMeters > fromDecimetres(width)) return true;
+  const length = limits.lengthDecimetres[index];
+  if (length && vehicle.lengthMeters > fromDecimetres(length)) return true;
+  const weight = limits.weightHalfTonnes[index];
+  return Boolean(weight) && vehicle.weightTonnes > fromHalfTonnes(weight);
+}
+function accessForVehicle(graph, vehicle) {
+  const limits = graph.edgeLimits;
+  if (!vehicle || !limits?.edges.length) return graph.edgeAccess;
+  const edges = graph.edgeTargets.length;
+  const mask = graph.edgeAccess ? Uint8Array.from(graph.edgeAccess) : accessMaskFor(edges, () => true);
+  for (let index = 0; index < limits.edges.length; index += 1) {
+    const edge = limits.edges[index];
+    if (edge < edges && blocks(limits, index, vehicle)) mask[edge >> 3] &= ~(1 << (edge & 7));
+  }
+  return mask;
+}
+function countBlocked(graph, vehicle) {
+  const mask = accessForVehicle(graph, vehicle);
+  if (!mask) return 0;
+  let blocked = 0;
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) if (!edgeAllowed(mask, edge)) blocked += 1;
+  return blocked;
+}
+
+// src/types.ts
+var RouterError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "RouterError";
+  }
+  code;
+};
+
+// 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) {
+    if (!edgeAllowed(graph.restrictionMask, pair)) continue;
+    const banned = index.get(fromEdges[pair]);
+    if (banned) banned.add(toEdges[pair]);
+    else index.set(fromEdges[pair], /* @__PURE__ */ new Set([toEdges[pair]]));
+  }
+  return index.size ? index : null;
+}
+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();
+  const pairs = graph.turnRestrictionFromEdges?.length ?? 0;
+  for (let index = 0; index + 1 < offsets.length; index += 1) {
+    if (!edgeAllowed(graph.restrictionMask, pairs + index)) continue;
+    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 };
+}
+var guardedCache = /* @__PURE__ */ new WeakMap();
+function guardedJunctionsFor(graph, restrictions, sequences) {
+  const held = guardedCache.get(graph);
+  if (held) return held;
+  const nodes = graph.nodeLatitudes.length;
+  const edges = graph.edgeTargets.length;
+  const guarded = new Uint8Array(nodes);
+  if (restrictions) for (const edge of restrictions.keys()) guarded[graph.edgeTargets[edge]] = 1;
+  if (sequences) {
+    for (const sequence of sequences.sequences) {
+      for (const edge of sequence) guarded[graph.edgeTargets[edge]] = 1;
+    }
+  }
+  const stateOfEdge = new Int32Array(edges).fill(-1);
+  let count = 0;
+  for (let edge = 0; edge < edges; edge += 1) if (guarded[graph.edgeTargets[edge]]) stateOfEdge[edge] = count++;
+  const edgeOfState = new Int32Array(count);
+  for (let edge = 0; edge < edges; edge += 1) if (stateOfEdge[edge] >= 0) edgeOfState[stateOfEdge[edge]] = edge;
+  const index = { guarded, stateOfEdge, edgeOfState, count };
+  guardedCache.set(graph, index);
+  return index;
+}
+
+// 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 ROADS_TO_TRY = 6;
+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, slowed) {
+  const distanceScale = graph.edgeDistanceScale ?? 1;
+  const durationScale = graph.edgeDurationScale ?? 1;
+  const { maxSpeedMps, longitudeMetresPerDegree } = searchBoundsFor(graph);
+  const coordinateScale = graph.coordinateScale ?? 1;
+  const latitudes = graph.nodeLatitudes;
+  const longitudes = graph.nodeLongitudes;
+  const destinationLatitude = destinationPoint.lat;
+  const destinationLongitude = destinationPoint.lng;
+  const toCost = preference === "fastest" ? 1 / maxSpeedMps : 1;
+  return {
+    // An overridden cost only ever exceeds the graph's own — a conditional
+    // limit slows an edge and a penalty makes it dearer — so the heuristic
+    // built from the graph's fastest edge stays a lower bound and the search
+    // still returns the best route under the costs it was given.
+    costOf: (edge) => slowed?.get(edge) ?? (preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale),
+    // Called once per relaxation, millions of times on a long route, so it
+    // reads the coordinate arrays directly and avoids a haversine's four
+    // trigonometric calls for a number that only has to be a lower bound.
+    heuristicFor: (node) => straightLineAtMost(
+      latitudes[node] / coordinateScale,
+      longitudes[node] / coordinateScale,
+      destinationLatitude,
+      destinationLongitude,
+      longitudeMetresPerDegree
+    ) * toCost
+  };
+}
+function searchByNode(graph, seeds, finishers, destinationPoint, preference, costBound, access, slowed) {
+  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference, slowed);
+  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) {
+      if (!edgeAllowed(access, edge)) continue;
+      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 searchWithRestrictions(graph, seeds, finishers, destinationPoint, preference, restrictions, sequenceIndex, costBound, access, slowed) {
+  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference, slowed);
+  const targets = graph.edgeTargets;
+  const { guarded, stateOfEdge, edgeOfState, count: guardedStates } = guardedJunctionsFor(graph, restrictions, sequenceIndex);
+  const nodes = graph.nodeLatitudes.length;
+  const plainBase = guardedStates;
+  const stateCount = guardedStates + nodes;
+  const costs = new Float64Array(stateCount).fill(Infinity);
+  const cameFrom = new Int32Array(stateCount).fill(-1);
+  const cameVia = new Int32Array(stateCount).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 nodeOf = (state) => {
+    if (state < guardedStates) return targets[edgeOfState[state]];
+    if (state < stateCount) return state - plainBase;
+    return targets[partialEdge[state - stateCount]];
+  };
+  const arrivalOf = (state) => {
+    if (state < guardedStates) return edgeOfState[state];
+    if (state < stateCount) return cameVia[state];
+    return partialEdge[state - stateCount];
+  };
+  const matchesOf = (state) => state < stateCount ? void 0 : partialMatches[state - stateCount];
+  const costOfState = (state) => state < stateCount ? costs[state] : partialCost[state - stateCount];
+  const bansAt = (state) => state < guardedStates || state >= stateCount ? restrictions?.get(arrivalOf(state)) : void 0;
+  const relax = (state, cost, from, via, seed2) => {
+    if (state < stateCount) {
+      if (cost >= costs[state]) return;
+      costs[state] = cost;
+      cameFrom[state] = from;
+      cameVia[state] = via;
+      if (from === -1 && seed2) seedOf.set(state, seed2);
+    } else {
+      const slot = state - stateCount;
+      if (cost >= partialCost[slot]) return;
+      partialCost[slot] = cost;
+      partialPrevious[slot] = from;
+    }
+    queue.push(state, cost + heuristicFor(nodeOf(state)));
+  };
+  const stateFor = (edge, matches) => {
+    if (!matches.length) {
+      const node = targets[edge];
+      return guarded[node] ? stateOfEdge[edge] : plainBase + node;
+    }
+    const key = `${edge}:${matches.sort((a, b) => a - b).join(",")}`;
+    let id = partialIds.get(key);
+    if (id === void 0) {
+      id = stateCount + 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 banned = bansAt(state);
+    const edge = arrivalOf(state);
+    for (const finisher of finishers.get(node) ?? []) {
+      if (finisher.edge >= 0 && banned?.has(finisher.edge)) continue;
+      if (finisher.edge >= 0 && 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) {
+      const state = stateFor(seed2.edge, []);
+      relax(state, seed2.cost, -1, seed2.edge, seed2);
+      considerFinishers(state, 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) {
+      if (!edgeAllowed(access, edge)) continue;
+      relax(stateFor(edge, []), seed2.cost + costOf(edge), -1, edge, seed2);
+    }
+  }
+  while (queue.size) {
+    if (queue.minimumPriority >= best) break;
+    const state = queue.pop();
+    const node = nodeOf(state);
+    const matches = matchesOf(state);
+    const banned = bansAt(state);
+    const arrival = arrivalOf(state);
+    considerFinishers(state, node, null);
+    for (let next = graph.edgeOffsets[node]; next < graph.edgeOffsets[node + 1]; next += 1) {
+      if (banned?.has(next) || !edgeAllowed(access, next)) continue;
+      const carried = arrival >= 0 && (state < guardedStates || state >= stateCount) ? advance(arrival, matches, next) : [];
+      if (carried === null) continue;
+      relax(stateFor(next, carried), costOfState(state) + costOf(next), state, next, null);
+    }
+  }
+  if (!bestFinisher) return null;
+  const chain = [];
+  for (let state = bestArrival; state !== -1; ) {
+    const via = state < stateCount ? cameVia[state] : partialEdge[state - stateCount];
+    if (via >= 0) chain.push(via);
+    state = state < stateCount ? cameFrom[state] : partialPrevious[state - stateCount];
+  }
+  chain.reverse();
+  const seed = bestSeed ?? (chain.length ? seedOf.get(stateFor(chain[0], [])) ?? seeds[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, travelledMeters = 0) {
+  return snap.kind === "node" ? { node: snap.node, edge: -1, point: snap.point, distanceMeters: snap.distanceMeters, travelledMeters: 0 } : { node: -1, edge: snap.projections[0].edge, point: snap.point, distanceMeters: snap.distanceMeters, travelledMeters };
+}
+function withPenalties(graph, preference, slowed, penalties) {
+  if (!penalties?.size) return slowed;
+  const distanceScale = graph.edgeDistanceScale ?? 1;
+  const durationScale = graph.edgeDurationScale ?? 1;
+  const costs = new Map(slowed);
+  for (const [edge, multiplier] of penalties) {
+    const base = costs.get(edge) ?? (preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale);
+    costs.set(edge, base * multiplier);
+  }
+  return costs;
+}
+function departureTime(options) {
+  const departAt = options.departAt;
+  if (!departAt) return void 0;
+  return departAt instanceof Date ? travelTimeFrom(departAt, options.publicHoliday, options.timeZone) : { ...departAt, publicHoliday: departAt.publicHoliday ?? options.publicHoliday };
+}
+function nodeOfSnap(snap) {
+  return snap.kind === "node" ? snap.node : snap.projections[0].source;
+}
+function reconnect(graph, from, to, preference, options, access) {
+  const originSnap = snapToGraph(graph, from, void 0, access);
+  const destinationSnap = snapToGraph(graph, to, void 0, access);
+  if (!originSnap || !destinationSnap) return null;
+  const labels = componentsFor(graph);
+  const originLabel = labels[nodeOfSnap(originSnap)];
+  const destinationLabel = labels[nodeOfSnap(destinationSnap)];
+  if (originLabel === destinationLabel) return null;
+  const sizes = componentSizes(labels);
+  const moveOrigin = (sizes.get(originLabel) ?? 0) <= (sizes.get(destinationLabel) ?? 0);
+  const wanted = moveOrigin ? destinationLabel : originLabel;
+  const accept = (node) => labels[node] === wanted;
+  try {
+    return routeBetween(graph, from, to, preference, options, access, moveOrigin ? accept : void 0, moveOrigin ? void 0 : accept);
+  } catch {
+    return null;
+  }
+}
+function route(graph, from, to, preference = "fastest", options = {}) {
+  assertGraph(graph);
+  const vehicleAccess = accessForVehicle(graph, options.vehicle);
+  const timed = accessAtTime(graph, conditionsOf(graph), departureTime(options), options.vehicle, vehicleAccess, options.circumstances);
+  const access = accessAvoiding(graph, options.avoid, timed);
+  try {
+    return routeBetween(graph, from, to, preference, options, access);
+  } catch (error) {
+    if (!(error instanceof RouterError) || error.code !== "NO_ROUTE") throw error;
+    const mended = reconnect(graph, from, to, preference, options, access);
+    if (mended) return mended;
+    if (options.finishOnANearbyRoad === false) throw error;
+    return onAnotherRoad(graph, from, to, preference, options, access) ?? (() => {
+      throw error;
+    })();
+  }
+}
+function roadsNear(graph, point, access) {
+  const nearby = snapToGraph(graph, point, FALLBACK_SNAP_RADIUS_METERS, access, void 0, true);
+  if (!nearby || nearby.kind === "node") return nearby ? [nearby] : [];
+  const byRoad = /* @__PURE__ */ new Map();
+  for (const projection of nearby.projections) {
+    const key = `${Math.min(projection.source, projection.target)}:${Math.max(projection.source, projection.target)}`;
+    const held = byRoad.get(key);
+    if (held) held.push(projection);
+    else byRoad.set(key, [projection]);
+  }
+  return [...byRoad.values()].map((projections) => ({
+    kind: "edge",
+    projections,
+    point: projections[0].point,
+    distanceMeters: projections[0].distanceMeters
+  }));
+}
+function onAnotherRoad(graph, from, to, preference, options, access) {
+  const attempt = (chosen) => {
+    try {
+      return routeBetween(graph, from, to, preference, options, access, void 0, void 0, chosen);
+    } catch {
+      return null;
+    }
+  };
+  for (const destination of roadsNear(graph, to, access).slice(1, ROADS_TO_TRY + 1)) {
+    const found = attempt({ destination });
+    if (found) return found;
+  }
+  for (const origin of roadsNear(graph, from, access).slice(1, ROADS_TO_TRY + 1)) {
+    const found = attempt({ origin });
+    if (found) return found;
+  }
+  return null;
+}
+function routeBetween(graph, from, to, preference, options, access, acceptOrigin, acceptDestination, chosen) {
+  const originSnap = chosen?.origin ?? snapToGraph(graph, from, void 0, access, acceptOrigin);
+  if (!originSnap) throw new RouterError("ORIGIN_NOT_ON_GRAPH", "No routable road is close to the origin.");
+  const destinationSnap = chosen?.destination ?? snapToGraph(graph, to, void 0, access, acceptDestination);
+  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 when = departureTime(options);
+  const conditionallySlowed = preference === "fastest" && when ? conditionalDurations(graph, conditionsOf(graph), when, options.vehicle, options.circumstances) : void 0;
+  const slowed = withPenalties(graph, preference, conditionallySlowed, options.costPenalties);
+  const costOf = (edge) => preference === "fastest" ? conditionallySlowed?.get(edge) ?? 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 ? searchWithRestrictions(graph, seeds, finishers, destinationSnap.point, preference, restrictions, sequenceIndex, costBound, access, slowed) : searchByNode(graph, seeds, finishers, destinationSnap.point, preference, costBound, access, slowed);
+  if (direct && direct.cost >= costBound) direct = null;
+  if (!outcome && !direct) throw new RouterError("NO_ROUTE", `No ${profileOf(graph).name} 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;
+  let travelledAtOrigin = 0;
+  let travelledAtDestination = 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;
+    travelledAtOrigin = span.distance;
+  } 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;
+      travelledAtOrigin = span.distance;
+      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 += conditionallySlowed?.get(edge) ?? 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;
+      travelledAtDestination = span.distance;
+    }
+  }
+  return {
+    nodeIds,
+    edgeIds,
+    distanceMeters,
+    durationSeconds,
+    originSnap: snapSummary(originSnap, travelledAtOrigin),
+    destinationSnap: snapSummary(destinationSnap, travelledAtDestination),
+    geometry: { type: "LineString", coordinates }
+  };
+}
+
+export {
+  accessMaskFor,
+  edgeAllowed,
+  allowsEverything,
+  zigzag,
+  unzigzag,
+  VarintWriter,
+  VarintReader,
+  parseMaxSpeedKph,
+  MAX_STORED_VALUES,
+  parseConditional,
+  conditionHolds,
+  conditionalValue,
+  unreadableConditions,
+  travelTimeFrom,
+  ConditionKind,
+  packEdgeConditions,
+  parseEdgeConditions,
+  conditionsOnEdge,
+  accessAtTime,
+  countClosedAt,
+  conditionsOf,
+  conditionalDurations,
+  ProfileId,
+  parseLengthMeters,
+  parseWeightTonnes,
+  carRoutingProfile,
+  motorcycleRoutingProfile,
+  truckRoutingProfile,
+  routingProfiles,
+  getRoutingProfile,
+  getRoutingProfileById,
+  profileOf,
+  maxSpeedMpsFor,
+  encodeGraph,
+  decodeGraph,
+  encodeCompactGraph,
+  encodeSharedGraph,
+  encodeProfileChunk,
+  decodeProfileChunk,
+  decodeSharedGraph,
+  combineProfiledGraph,
+  searchBoundsFor,
+  straightLineAtMost,
+  componentsFor,
+  componentSizes,
+  edgeSource,
+  edgePolyline,
+  createEdgeSpatialIndex,
+  edgeSpatialIndexFor,
+  nearbyEdgeIds,
+  createSpatialIndex,
+  withSpatialIndex,
+  snapToGraph,
+  touchesArea,
+  accessAvoiding,
+  countAvoided,
+  toDecimetres,
+  toHalfTonnes,
+  fromDecimetres,
+  fromHalfTonnes,
+  packEdgeLimits,
+  accessForVehicle,
+  countBlocked,
+  RouterError,
+  buildTurnRestrictionIndex,
+  isTurnBanned,
+  packTurnRestrictions,
+  buildTurnSequenceIndex,
+  packTurnSequences,
+  guardedJunctionsFor,
+  findNearestNode,
+  route
+};