@riebeckite/plugin-map 0.0.6

package/dist/index.js

@@ -0,0 +1,628 @@
+// index.ts
+import {
+  createClientEntry,
+  createStyleAsset,
+  definePlugin
+} from "@riebeckite/core";
+
+// src/options.ts
+var DEFAULT_MAP_CLASS_NAME = "rr-map";
+var DEFAULT_MAP_HEIGHT = 320;
+var DEFAULT_MAP_LANGUAGE = "map";
+var DEFAULT_MAP_ZOOM = 13;
+var DEFAULT_MAP_MIN_ZOOM = 1;
+var DEFAULT_MAP_MAX_ZOOM = 19;
+var DEFAULT_MAP_FRONTMATTER_KEY = "map";
+var DEFAULT_MAP_TILE_URL = "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
+var DEFAULT_MAP_ATTRIBUTION = '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors';
+function resolveMapOptions(options = {}) {
+  return {
+    language: normalizeText(options.language, DEFAULT_MAP_LANGUAGE),
+    className: normalizeText(options.className, DEFAULT_MAP_CLASS_NAME),
+    height: normalizePositive(options.height, DEFAULT_MAP_HEIGHT),
+    zoom: clampZoom(options.zoom ?? DEFAULT_MAP_ZOOM),
+    minZoom: clampZoom(options.minZoom ?? DEFAULT_MAP_MIN_ZOOM, 0),
+    maxZoom: clampZoom(options.maxZoom ?? DEFAULT_MAP_MAX_ZOOM, 0),
+    tileUrl: normalizeText(options.tileUrl, DEFAULT_MAP_TILE_URL),
+    attribution: normalizeText(options.attribution, DEFAULT_MAP_ATTRIBUTION),
+    fallback: options.fallback !== false,
+    staticFallback: options.staticFallback !== false,
+    staticImageUrl: normalizeOptionalText(options.staticImageUrl),
+    frontmatterKey: normalizeText(
+      options.frontmatterKey,
+      DEFAULT_MAP_FRONTMATTER_KEY
+    )
+  };
+}
+function normalizeText(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  const trimmed = value.trim();
+  return trimmed === "" ? fallback : trimmed;
+}
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+function normalizePositive(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function clampZoom(value, minimum = 1) {
+  if (!Number.isFinite(value)) return minimum;
+  const rounded = Math.round(value);
+  if (rounded < minimum) return minimum;
+  if (rounded > 19) return 19;
+  return rounded;
+}
+
+// src/hast.ts
+function visitElements(node, visitor, parent, index) {
+  if (isElementNode(node)) visitor(node, parent, index);
+  for (const [childIndex, child] of [...getChildren(node)].entries()) {
+    visitElements(
+      child,
+      visitor,
+      hasChildren(node) ? node : parent,
+      childIndex
+    );
+  }
+}
+function element(tagName, properties = {}, children = []) {
+  return { type: "element", tagName, properties, children };
+}
+function text(value) {
+  return { type: "text", value };
+}
+function getTextContent(node) {
+  if (node.type === "text" && "value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  return getChildren(node).map(getTextContent).join("");
+}
+function getStringProperty(node, key) {
+  const value = node.properties?.[key];
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.join(" ");
+  return null;
+}
+function hasClass(node, className) {
+  const value = node.properties?.className;
+  const classes = Array.isArray(value) ? value.map(String) : typeof value === "string" ? value.split(/\s+/) : [];
+  return classes.includes(className);
+}
+function isElementNode(node) {
+  return node.type === "element";
+}
+function hasChildren(node) {
+  return Array.isArray(node.children);
+}
+function getChildren(node) {
+  const children = node.children;
+  return Array.isArray(children) ? children : [];
+}
+
+// src/parse.ts
+var KEY_VALUE = /^([A-Za-z][\w-]*)\s*:\s*(.*)$/;
+var BULLET = /^\s*[-*]\s+(.*)$/;
+var COORDINATES = /^(-?\d+(?:\.\d+)?)\s*[,\s]\s*(-?\d+(?:\.\d+)?)$/;
+function parseMapSource(source) {
+  const markers = [];
+  let center;
+  let zoom;
+  let label;
+  let tiles;
+  let attribution;
+  let image;
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const bullet = BULLET.exec(rawLine);
+    if (bullet) {
+      const marker = parseMarker(bullet[1]);
+      if (marker) markers.push(marker);
+      continue;
+    }
+    const keyValue = KEY_VALUE.exec(line);
+    if (keyValue) {
+      const key = keyValue[1].toLowerCase();
+      const value = keyValue[2].trim();
+      switch (key) {
+        case "center": {
+          const parsed = parseCoordinates(value);
+          if (parsed) center = parsed;
+          break;
+        }
+        case "zoom": {
+          const parsed = parseZoom(value);
+          if (parsed !== void 0) zoom = parsed;
+          break;
+        }
+        case "label":
+        case "title":
+        case "place":
+          label = value || void 0;
+          break;
+        case "tiles":
+        case "tile":
+        case "tileurl":
+          tiles = value || void 0;
+          break;
+        case "attribution":
+          attribution = value || void 0;
+          break;
+        case "image":
+        case "staticimage":
+          image = value || void 0;
+          break;
+        default:
+          break;
+      }
+      continue;
+    }
+    const coordinates = parseCoordinates(line);
+    if (coordinates) markers.push(coordinates);
+  }
+  if (markers.length === 0 && !center) return null;
+  const data = { markers };
+  if (center) data.center = center;
+  else if (markers[0])
+    data.center = { lat: markers[0].lat, lng: markers[0].lng };
+  if (zoom !== void 0) data.zoom = zoom;
+  if (label) data.label = label;
+  if (tiles) data.tiles = tiles;
+  if (attribution) data.attribution = attribution;
+  if (image) data.image = image;
+  return data;
+}
+function normalizeMapInput(value) {
+  if (typeof value === "string") {
+    const direct = parseCoordinates(value);
+    return direct ? { markers: [direct], center: direct } : null;
+  }
+  if (Array.isArray(value)) {
+    const pair = coordinateFromArray(value);
+    if (pair) return { markers: [pair], center: pair };
+    const markers2 = value.map((item) => markerFromUnknown(item)).filter((marker) => marker !== null);
+    if (markers2.length === 0) return null;
+    return { markers: markers2, center: { lat: markers2[0].lat, lng: markers2[0].lng } };
+  }
+  if (!isRecord(value)) return null;
+  const markers = Array.isArray(value.markers) ? value.markers.map((item) => markerFromUnknown(item)).filter((marker) => marker !== null) : [];
+  const center = (readNumber(value, "lat", "latitude") !== void 0 && readNumber(value, "lng", "lon", "longitude") !== void 0 ? {
+    lat: readNumber(value, "lat", "latitude"),
+    lng: readNumber(value, "lng", "lon", "longitude")
+  } : void 0) ?? parseCoordinatesValue(value.coordinates) ?? (markers[0] ? { lat: markers[0].lat, lng: markers[0].lng } : void 0);
+  if (!center && markers.length === 0) return null;
+  const data = { markers };
+  if (center) data.center = center;
+  const zoom = readNumber(value, "zoom");
+  if (zoom !== void 0) {
+    const normalized = normalizeZoom(zoom);
+    if (normalized !== void 0) data.zoom = normalized;
+  }
+  const label = readString(value, "label", "title", "place", "name");
+  if (label) data.label = label;
+  const tiles = readString(value, "tiles", "tile", "tileUrl", "tile_url");
+  if (tiles) data.tiles = tiles;
+  const attribution = readString(value, "attribution");
+  if (attribution) data.attribution = attribution;
+  const image = readString(value, "image", "staticImage", "static_image");
+  if (image) data.image = image;
+  return data;
+}
+function formatCoordinates(coordinates) {
+  return `${formatNumber(coordinates.lat)}, ${formatNumber(coordinates.lng)}`;
+}
+function describeMap(data) {
+  if (data.label) return data.label;
+  const named = data.markers.find((marker) => marker.label);
+  if (named?.label) return named.label;
+  if (data.center) return formatCoordinates(data.center);
+  return "";
+}
+function openStreetMapUrl(coordinates, zoom) {
+  const level = normalizeZoom(zoom) ?? 13;
+  return `https://www.openstreetmap.org/?mlat=${coordinates.lat}&mlon=${coordinates.lng}#map=${level}/${coordinates.lat}/${coordinates.lng}`;
+}
+function parseMarker(value) {
+  const [coordinatesPart, label, description] = value.split("|").map((part) => part.trim());
+  const coordinates = parseCoordinates(coordinatesPart ?? "");
+  if (!coordinates) return null;
+  const marker = { ...coordinates };
+  if (label) marker.label = label;
+  if (description) marker.description = description;
+  return marker;
+}
+function markerFromUnknown(value) {
+  const stringMarker = typeof value === "string" ? parseMarker(value) : null;
+  if (stringMarker) return stringMarker;
+  if (Array.isArray(value)) {
+    const coordinates2 = coordinateFromArray(value);
+    if (!coordinates2) return null;
+    const label2 = typeof value[2] === "string" ? value[2].trim() : "";
+    const marker2 = { ...coordinates2 };
+    if (label2) marker2.label = label2;
+    return marker2;
+  }
+  if (!isRecord(value)) return null;
+  const lat = readNumber(value, "lat", "latitude");
+  const lng = readNumber(value, "lng", "lon", "longitude");
+  const coordinates = lat !== void 0 && lng !== void 0 ? validateCoordinates(lat, lng) : parseCoordinatesValue(value.coordinates);
+  if (!coordinates) return null;
+  const marker = { ...coordinates };
+  const label = readString(value, "label", "title", "name");
+  if (label) marker.label = label;
+  const description = readString(value, "description", "desc");
+  if (description) marker.description = description;
+  return marker;
+}
+function parseCoordinatesValue(value) {
+  if (typeof value === "string") return parseCoordinates(value);
+  if (Array.isArray(value)) return coordinateFromArray(value);
+  if (isRecord(value)) {
+    const lat = readNumber(value, "lat", "latitude");
+    const lng = readNumber(value, "lng", "lon", "longitude");
+    if (lat !== void 0 && lng !== void 0)
+      return validateCoordinates(lat, lng);
+  }
+  return null;
+}
+function coordinateFromArray(value) {
+  const lat = typeof value[0] === "number" ? value[0] : void 0;
+  const lng = typeof value[1] === "number" ? value[1] : void 0;
+  if (lat === void 0 || lng === void 0) return null;
+  return validateCoordinates(lat, lng);
+}
+function parseCoordinates(value) {
+  const normalized = value.trim().replace(/^[[(]\s*/, "").replace(/\s*[\])]$/, "").trim();
+  const match = COORDINATES.exec(normalized);
+  if (!match) return null;
+  return validateCoordinates(Number(match[1]), Number(match[2]));
+}
+function validateCoordinates(lat, lng) {
+  if (!Number.isFinite(lat) || !Number.isFinite(lng)) return null;
+  if (lat < -90 || lat > 90) return null;
+  if (lng < -180 || lng > 180) return null;
+  return { lat, lng };
+}
+function parseZoom(value) {
+  const parsed = Number(value.trim());
+  if (!Number.isFinite(parsed)) return void 0;
+  return normalizeZoom(parsed);
+}
+function normalizeZoom(value) {
+  if (!Number.isFinite(value)) return void 0;
+  const rounded = Math.round(value);
+  if (rounded < 0) return 0;
+  if (rounded > 19) return 19;
+  return rounded;
+}
+function readNumber(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim() !== "") {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return void 0;
+}
+function readString(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  return void 0;
+}
+function formatNumber(value) {
+  return String(Math.round(value * 1e5) / 1e5);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/rehype.ts
+var DIAGNOSTIC_SOURCE = "@riebeckite/plugin-map";
+var STATIC_IMAGE_WIDTH = 640;
+function rehypeMap(options = {}) {
+  const resolved = resolveMapOptions(options);
+  return (tree, file) => {
+    visitElements(tree, (node, parent, index) => {
+      if (!parent || index === void 0) return;
+      if (!isMapCodeBlock(node, resolved.language)) return;
+      replaceMapBlock(parent, index, node, file, resolved);
+    });
+    const frontmatter = readFrontmatter(file);
+    if (frontmatter) {
+      const data = normalizeMapInput(frontmatter[resolved.frontmatterKey]);
+      if (data) {
+        const figure = buildFigure({
+          data,
+          options: resolved,
+          caption: data.label ?? null
+        });
+        getRootChildren(tree).unshift(figure);
+      }
+    }
+  };
+}
+function replaceMapBlock(parent, index, pre, file, options) {
+  const code = findDirectChild(pre, "code");
+  const source = code ? getTextContent(code).trim() : getTextContent(pre).trim();
+  const data = parseMapSource(source);
+  if (data === null) {
+    reportDiagnostic(
+      file,
+      "Expected at least one coordinate or a `center` value."
+    );
+    return;
+  }
+  const caption = extractCaption(pre, code) ?? data.label ?? null;
+  parent.children = parent.children ?? [];
+  parent.children[index] = buildFigure({
+    data,
+    options,
+    caption,
+    source
+  });
+}
+function buildFigure(input) {
+  const { data, options } = input;
+  const center = data.center ?? data.markers[0];
+  if (!center) {
+    return element("div", { className: options.className });
+  }
+  const tiles = data.tiles ?? options.tileUrl;
+  const attribution = data.attribution ?? options.attribution;
+  const image = resolveStaticImage(
+    data.image ?? options.staticImageUrl,
+    center,
+    data.zoom ?? options.zoom,
+    options.height
+  );
+  const payload = {
+    markers: data.markers,
+    center,
+    zoom: data.zoom ?? options.zoom,
+    label: data.label ?? null,
+    tiles,
+    attribution,
+    image
+  };
+  const described = describeMap(data);
+  const label = input.caption ?? (described || "Map");
+  const labelId = `${options.className}-caption`;
+  const children = [];
+  if (input.caption) {
+    children.push(
+      element(
+        "figcaption",
+        { id: labelId, className: `${options.className}__caption` },
+        [text(input.caption)]
+      )
+    );
+  }
+  children.push(
+    element(
+      "div",
+      {
+        className: `${options.className}__canvas`,
+        dataRrMapCanvas: "true",
+        style: `height:${options.height}px`,
+        role: "application",
+        ariaLabelledby: input.caption ? labelId : void 0,
+        ariaLabel: input.caption ? void 0 : label
+      },
+      []
+    )
+  );
+  if (options.staticFallback) {
+    children.push(buildStatic(data, payload, options.className));
+  }
+  if (options.fallback && input.source) {
+    children.push(
+      element("details", { className: `${options.className}__fallback` }, [
+        element("summary", {}, [text("Map source")]),
+        element("pre", {}, [element("code", {}, [text(input.source)])])
+      ])
+    );
+  }
+  return element(
+    "figure",
+    {
+      className: options.className,
+      dataRrMap: "pending",
+      dataRrMapPayload: JSON.stringify(payload),
+      dataRrMapHeight: String(options.height)
+    },
+    children
+  );
+}
+function buildStatic(data, payload, base) {
+  const children = [];
+  if (payload.image) {
+    children.push(
+      element("img", {
+        className: `${base}__image`,
+        src: payload.image,
+        alt: describeMap(data) || "Map",
+        loading: "lazy",
+        decoding: "async"
+      })
+    );
+  }
+  if (payload.label) {
+    children.push(
+      element("p", { className: `${base}__place` }, [text(payload.label)])
+    );
+  }
+  const markers = payload.markers.length > 0 ? payload.markers : [payload.center];
+  children.push(
+    element(
+      "ul",
+      { className: `${base}__markers` },
+      markers.map((marker) => buildMarker(marker, payload.zoom, base))
+    )
+  );
+  const attribution = stripHtml(payload.attribution);
+  if (attribution) {
+    children.push(
+      element("p", { className: `${base}__attribution` }, [text(attribution)])
+    );
+  }
+  return element(
+    "div",
+    { className: `${base}__static`, dataRrMapStatic: "true" },
+    children
+  );
+}
+function buildMarker(marker, zoom, base) {
+  const coordinates = formatCoordinates(marker);
+  const label = marker.label ? `${marker.label} · ${coordinates}` : coordinates;
+  const children = [
+    element(
+      "a",
+      {
+        className: `${base}__link`,
+        href: openStreetMapUrl(marker, zoom),
+        target: "_blank",
+        rel: "noopener noreferrer"
+      },
+      [text(label)]
+    )
+  ];
+  if (marker.description) {
+    children.push(
+      element("span", { className: `${base}__description` }, [
+        text(` — ${marker.description}`)
+      ])
+    );
+  }
+  return element("li", { className: `${base}__marker` }, children);
+}
+function resolveStaticImage(template, center, zoom, height) {
+  if (!template) return null;
+  return template.replaceAll("{lat}", String(center.lat)).replaceAll("{lng}", String(center.lng)).replaceAll("{zoom}", String(zoom)).replaceAll("{width}", String(STATIC_IMAGE_WIDTH)).replaceAll("{height}", String(height));
+}
+function extractCaption(pre, code) {
+  const title = getStringProperty(pre, "title") ?? (code ? getStringProperty(code, "title") : null);
+  return title?.trim() || null;
+}
+function isMapCodeBlock(node, language) {
+  if (node.tagName !== "pre") return false;
+  const code = findDirectChild(node, "code");
+  return Boolean(code && hasClass(code, `language-${language}`));
+}
+function findDirectChild(node, tagName) {
+  return node.children?.find(
+    (child) => child.type === "element" && child.tagName === tagName
+  ) ?? null;
+}
+function readFrontmatter(file) {
+  const matter = file?.data?.matter;
+  if (typeof matter !== "object" || matter === null || Array.isArray(matter)) {
+    return null;
+  }
+  return matter;
+}
+function getRootChildren(tree) {
+  const children = tree.children;
+  if (!Array.isArray(children)) {
+    tree.children = [];
+    return tree.children;
+  }
+  return children;
+}
+function reportDiagnostic(file, message) {
+  const reporter = file?.message;
+  if (typeof reporter !== "function") return;
+  const diagnostic = reporter.call(file, `Invalid map source: ${message}`);
+  if (diagnostic && typeof diagnostic === "object") {
+    Object.assign(diagnostic, {
+      source: DIAGNOSTIC_SOURCE,
+      ruleId: "invalid-source"
+    });
+  }
+}
+function stripHtml(value) {
+  return value.replace(/<[^>]*>/g, "").replace(/&copy;/gi, "©").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/g, "'").replace(/&amp;/gi, "&").replace(/\s+/g, " ").trim();
+}
+
+// index.ts
+var MAP_PLUGIN_NAME = "map";
+function map(options = {}) {
+  const resolved = resolveMapOptions(options);
+  return definePlugin({
+    name: MAP_PLUGIN_NAME,
+    order: -10,
+    options,
+    validateOptions: validateMapOptions,
+    extendHtmlPipeline: (pipeline) => {
+      pipeline.use(rehypeMap, options);
+    },
+    assets: [createStyleAsset(MAP_PLUGIN_NAME)],
+    clientEntries: [
+      createClientEntry(MAP_PLUGIN_NAME, "initMap", {
+        tileUrl: resolved.tileUrl,
+        attribution: resolved.attribution,
+        minZoom: resolved.minZoom,
+        maxZoom: resolved.maxZoom
+      })
+    ]
+  });
+}
+var mapPlugin = map;
+function validateMapOptions(options) {
+  if (!options) return [];
+  const issues = [];
+  for (const key of [
+    "language",
+    "className",
+    "tileUrl",
+    "attribution",
+    "staticImageUrl",
+    "frontmatterKey"
+  ]) {
+    const value = options[key];
+    if (value !== void 0 && (typeof value !== "string" || value.trim() === "")) {
+      issues.push({ path: key, message: "Expected a non-empty string." });
+    }
+  }
+  if (options.height !== void 0 && (typeof options.height !== "number" || !Number.isFinite(options.height) || options.height <= 0)) {
+    issues.push({ path: "height", message: "Expected a positive number." });
+  }
+  for (const key of ["zoom", "minZoom", "maxZoom"]) {
+    const value = options[key];
+    if (value !== void 0 && (!Number.isInteger(value) || value < 0 || value > 19)) {
+      issues.push({
+        path: key,
+        message: "Expected an integer between 0 and 19."
+      });
+    }
+  }
+  for (const key of ["fallback", "staticFallback"]) {
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") {
+      issues.push({ path: key, message: "Expected a boolean." });
+    }
+  }
+  if (typeof options.minZoom === "number" && typeof options.maxZoom === "number" && options.minZoom > options.maxZoom) {
+    issues.push({
+      path: "maxZoom",
+      message: "Expected maxZoom to be greater than or equal to minZoom."
+    });
+  }
+  return issues;
+}
+export {
+  MAP_PLUGIN_NAME,
+  describeMap,
+  formatCoordinates,
+  map,
+  mapPlugin,
+  normalizeMapInput,
+  openStreetMapUrl,
+  parseMapSource,
+  rehypeMap,
+  resolveMapOptions
+};

package/dist/src/hast.d.ts

@@ -0,0 +1,7 @@
+import type { ElementNode, HastNode, ParentNode, TextNode } from "./types.js";
+export declare function visitElements(node: HastNode, visitor: (node: ElementNode, parent?: ParentNode, index?: number) => void, parent?: ParentNode, index?: number): void;
+export declare function element(tagName: string, properties?: Record<string, unknown>, children?: HastNode[]): ElementNode;
+export declare function text(value: string): TextNode;
+export declare function getTextContent(node: HastNode): string;
+export declare function getStringProperty(node: ElementNode, key: string): string | null;
+export declare function hasClass(node: ElementNode, className: string): boolean;

package/dist/src/init.d.ts

@@ -0,0 +1,11 @@
+import type { MapClientOptions } from "./types.js";
+/**
+ * Upgrades every server-emitted `[data-rr-map="pending"]` figure to an
+ * interactive Leaflet map.
+ *
+ * Leaflet is fetched lazily from the CDN only when at least one map is
+ * present, so pages without maps pay nothing. The map data travels in
+ * `data-rr-map-payload`, which means the page still renders its static
+ * fallback when JavaScript is disabled or the CDN is unreachable.
+ */
+export declare function initMap(options?: MapClientOptions): Promise<void>;

package/dist/src/options.d.ts

@@ -0,0 +1,30 @@
+import type { MapOptions, ResolvedMapOptions } from "./types.js";
+/** Default base class for the generated figure. */
+export declare const DEFAULT_MAP_CLASS_NAME = "rr-map";
+/** Default map height in pixels. */
+export declare const DEFAULT_MAP_HEIGHT = 320;
+/** Default fenced-code language. */
+export declare const DEFAULT_MAP_LANGUAGE = "map";
+/** Default zoom level. */
+export declare const DEFAULT_MAP_ZOOM = 13;
+/** Default minimum zoom level. */
+export declare const DEFAULT_MAP_MIN_ZOOM = 1;
+/** Default maximum zoom level (OpenStreetMap's standard maximum). */
+export declare const DEFAULT_MAP_MAX_ZOOM = 19;
+/** Frontmatter property read for coordinates by default. */
+export declare const DEFAULT_MAP_FRONTMATTER_KEY = "map";
+/**
+ * Default OpenStreetMap tile template. It is keyless and safe to expose to the
+ * browser, but sites with meaningful traffic should follow the tile usage
+ * policy or point `tileUrl` at their own tile server.
+ */
+export declare const DEFAULT_MAP_TILE_URL = "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
+/** Attribution required by the default tile provider. */
+export declare const DEFAULT_MAP_ATTRIBUTION = "&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors";
+/**
+ * Applies defaults to the user-provided options.
+ *
+ * Shared by the plugin factory (for validation and `publicConfig`) and the
+ * rehype transformer (for figure emission), so both agree on one resolution.
+ */
+export declare function resolveMapOptions(options?: MapOptions): ResolvedMapOptions;