@superrouteca/smap 1.0.5 → 1.1.0

package/dist/smap.js

@@ -1,4 +1,4 @@
-/*! sMap Web SDK 1.0.5. Bundles maplibre-gl 6.16.0 (BSD-3-Clause), see vendor-licenses.txt. */
+/*! sMap Web SDK 1.1.0. Bundles maplibre-gl 6.16.0 (BSD-3-Clause), see vendor-licenses.txt. */
 (function () {
 function smapCreateEngine() {
   var SMAP_BASE_URL = (typeof document !== 'undefined' && document.baseURI) || (typeof location !== 'undefined' && location.href) || 'about:blank';
@@ -26846,12 +26846,1491 @@ ${o2.prelude.vertexSource}`, define: o2.define }, defaultProjectionData: d2, get
   smapEngine.setWorkerUrl(smapWorkerUrl);
   return smapEngine;
 }
-function smapCreateSdk(engine) {
+function smapCreateInterop() {
+  var module = { exports: {} };
+  var exports = module.exports;
+  var define;
+  var self = {};
+/*!
+ * sMap Web SDK — the parts that need no map: basemap classes and overrides, slots, file formats (read and write),
+ * the converting endpoint, raster tile URLs, PMTiles archives and WMTS capabilities. Pure functions, usable on a
+ * server; the map view (smap.js) is built on them. Rules shared by every SDK: smap-sdk shared/INTEROP-CONTRACT.md,
+ * shared/basemap-classes.json, shared/FORMAT-RULES.md, shared/LAYER-JSON.md.
+ */
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) { module.exports = factory(); } else { root.smapInterop = factory(); }
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  var DEFAULT_BASE = 'https://tile.srsr.ca';
+  var FLAVORS = ['light', 'white', 'grayscale', 'dark', 'black'];
+
+  // ------------------------------------------------------------------ basemap classes (contract §1)
+
+  // shared/basemap-classes.json, `paint` and `classes` as [layer, role] pairs (test/source-interop.test.cjs checks
+  // that it equals the shared file).
+  var BASEMAP = {"paint":{"background":{"color":"background-color","opacity":"background-opacity"},"fill":{"color":"fill-color","opacity":"fill-opacity"},"line":{"color":"line-color","opacity":"line-opacity","width":"line-width"},"casing":{"casing":"line-color","opacity":"line-opacity","width":"line-width"},"label":{"color":"text-color","halo":"text-halo-color","opacity":"text-opacity"}},"classes":{"land":[["background","background"],["earth","fill"]],"landcover":[["landcover","fill"]],"parks":[["landuse_park","fill"],["landuse_urban_green","fill"]],"landuse":[["landuse_hospital","fill"],["landuse_industrial","fill"],["landuse_school","fill"],["landuse_beach","fill"],["landuse_zoo","fill"],["landuse_pedestrian","fill"],["landuse_pier","fill"]],"airports":[["landuse_aerodrome","fill"],["roads_runway","line"],["roads_taxiway","line"],["landuse_runway","fill"]],"water":[["water","fill"],["water_stream","line"],["water_river","line"]],"roads.paths":[["roads_tunnels_other_casing","casing"],["roads_tunnels_other","line"],["roads_pier","line"],["roads_other","line"],["roads_bridges_other_casing","casing"],["roads_bridges_other","line"]],"roads.minor":[["roads_tunnels_minor_casing","casing"],["roads_tunnels_link_casing","casing"],["roads_tunnels_minor","line"],["roads_tunnels_link","line"],["roads_minor_service_casing","casing"],["roads_minor_casing","casing"],["roads_link_casing","casing"],["roads_link","line"],["roads_minor_service","line"],["roads_minor","line"],["roads_bridges_link_casing","casing"],["roads_bridges_minor_casing","casing"],["roads_bridges_minor","line"],["roads_bridges_link","line"]],"roads.major":[["roads_tunnels_major_casing","casing"],["roads_tunnels_major","line"],["roads_major_casing_late","casing"],["roads_major_casing_early","casing"],["roads_major","line"],["roads_bridges_major_casing","casing"],["roads_bridges_major","line"]],"roads.highway":[["roads_tunnels_highway_casing","casing"],["roads_tunnels_highway","line"],["roads_highway_casing_late","casing"],["roads_highway_casing_early","casing"],["roads_highway","line"],["roads_bridges_highway_casing","casing"],["roads_bridges_highway","line"]],"buildings":[["buildings","fill"]],"rail":[["roads_rail","line"]],"boundaries":[["boundaries_country","line"],["boundaries","line"]],"labels.addresses":[["address_label","label"]],"labels.water":[["water_waterway_label","label"],["water_label_ocean","label"],["water_label_lakes","label"]],"labels.roads":[["roads_oneway","label"],["roads_labels_minor","label"],["roads_shields","label"],["roads_labels_major","label"]],"labels.places":[["earth_label_islands","label"],["places_subplace","label"],["places_region","label"],["places_locality","label"],["places_country","label"]],"pois":[["pois","label"]]}};
+  var OVERRIDE_FIELDS = ['visible', 'color', 'casing', 'halo', 'opacity', 'width'];
+  var PARENTS = ['roads', 'labels'];
+
+  /** The class table as the shared file has it: {paint, classes: {name: [{layer, role}]}}. */
+  function basemapClasses() {
+    var classes = {};
+    Object.keys(BASEMAP.classes).forEach(function (name) {
+      classes[name] = BASEMAP.classes[name].map(function (p) { return { layer: p[0], role: p[1] }; });
+    });
+    return { paint: JSON.parse(JSON.stringify(BASEMAP.paint)), classes: classes };
+  }
+
+  // A table given as the shared file ({classes: {name: [{layer, role}]}}) or as the embedded one.
+  function classTable(table) {
+    if (!table) { return BASEMAP; }
+    var classes = {};
+    Object.keys(table.classes || {}).forEach(function (name) {
+      classes[name] = (table.classes[name] || []).map(function (p) { return Array.isArray(p) ? p : [p.layer, p.role]; });
+    });
+    return { paint: table.paint || BASEMAP.paint, classes: classes };
+  }
+
+  function isColor(v) { return typeof v === 'string' && v.length > 0; }
+
+  /**
+   * Checks basemap overrides (contract §1) and returns the list of [class, override] in the order they apply:
+   * parents (`roads`, `labels`) first, then the classes in the order given. An unknown class or field, or a value of
+   * the wrong kind, throws an Error naming it.
+   */
+  function overrideOrder(overrides, table) {
+    var t = classTable(table);
+    if (overrides === null || overrides === undefined) { return []; }
+    if (typeof overrides !== 'object' || Array.isArray(overrides)) { throw new Error('sMap: basemap overrides must be an object'); }
+    var parents = [], children = [];
+    Object.keys(overrides).forEach(function (name) {
+      var isParent = PARENTS.indexOf(name) >= 0;
+      if (!isParent && !t.classes[name]) { throw new Error('sMap: unknown basemap class "' + name + '"'); }
+      var o = overrides[name];
+      if (!o || typeof o !== 'object' || Array.isArray(o)) { throw new Error('sMap: basemap class "' + name + '" needs an object'); }
+      Object.keys(o).forEach(function (field) {
+        var v = o[field];
+        if (OVERRIDE_FIELDS.indexOf(field) < 0) { throw new Error('sMap: unknown field "' + field + '" on basemap class "' + name + '"'); }
+        if (field === 'visible' && typeof v !== 'boolean') { throw new Error('sMap: "' + name + '.visible" must be true or false'); }
+        if ((field === 'color' || field === 'casing' || field === 'halo') && !isColor(v)) { throw new Error('sMap: "' + name + '.' + field + '" must be a colour'); }
+        if (field === 'opacity' && !(typeof v === 'number' && v >= 0 && v <= 1)) { throw new Error('sMap: "' + name + '.opacity" must be between 0 and 1'); }
+        if (field === 'width' && !(typeof v === 'number' && v >= 0.25 && v <= 4)) { throw new Error('sMap: "' + name + '.width" must be between 0.25 and 4'); }
+      });
+      (isParent ? parents : children).push(name);
+    });
+    var out = [];
+    parents.sort(function (a, b) { return PARENTS.indexOf(a) - PARENTS.indexOf(b); });
+    parents.forEach(function (p) {
+      Object.keys(t.classes).forEach(function (name) { if (name.indexOf(p + '.') === 0) { out.push([name, overrides[p]]); } });
+    });
+    children.forEach(function (name) { out.push([name, overrides[name]]); });
+    return out;
+  }
+
+  function round4(n) { return Math.round(n * 10000) / 10000; }
+
+  // line-width × factor (contract §10): a number is multiplied (rounded to 4 decimals); a top-level interpolate /
+  // step (or legacy {stops}) keeps its structure with each output multiplied the same way, since the engine accepts
+  // a zoom expression only at the top of a value; anything else becomes ["*", factor, <original>]. Superroute's
+  // preview (SmapBasemapClasses::scaleWidth) gives the same values.
+  function scaledWidth(width, factor) {
+    if (typeof width === 'number') { return round4(width * factor); }
+    var k;
+    if (width && typeof width === 'object' && !Array.isArray(width) && Array.isArray(width.stops)) {
+      width = JSON.parse(JSON.stringify(width));
+      for (k = 0; k < width.stops.length; k++) { if (Array.isArray(width.stops[k]) && width.stops[k].length === 2) { width.stops[k][1] = scaledWidth(width.stops[k][1], factor); } }
+      return width;
+    }
+    if (Array.isArray(width) && width[0] === 'interpolate') {
+      width = width.slice();
+      for (k = 4; k < width.length; k += 2) { width[k] = scaledWidth(width[k], factor); }
+      return width;
+    }
+    if (Array.isArray(width) && width[0] === 'step') {
+      width = width.slice();
+      for (k = 2; k < width.length; k += 2) { width[k] = scaledWidth(width[k], factor); }
+      return width;
+    }
+    return ['*', factor, width];
+  }
+
+  // Applies one class's fields to one style layer of a role, in place. The width always scales the scheme's own
+  // width: the fields are merged (parent, then the class) before anything is applied.
+  function applyToLayer(layer, role, o, paintKeys) {
+    var keys = paintKeys[role] || {};
+    if (o.visible !== undefined) { layer.layout = layer.layout || {}; layer.layout.visibility = o.visible ? 'visible' : 'none'; }
+    var paint = function (k, v) { if (k) { layer.paint = layer.paint || {}; layer.paint[k] = v; } };
+    if (o.color !== undefined && role !== 'casing') { paint(keys.color, o.color); }
+    if (o.casing !== undefined && role === 'casing') { paint(keys.casing, o.casing); }
+    if (o.halo !== undefined && role === 'label') { paint(keys.halo, o.halo); }
+    if (o.opacity !== undefined) { paint(keys.opacity, o.opacity); }
+    if (o.width !== undefined && keys.width) {
+      var w = layer.paint ? layer.paint[keys.width] : undefined;
+      paint(keys.width, scaledWidth(w === undefined ? 1 : w, o.width));
+    }
+  }
+
+  /** The fields that apply to each class: its parent's (roads, labels), then its own, which win. */
+  function effectiveOverrides(overrides, table) {
+    var t = classTable(table);
+    overrideOrder(overrides, table);
+    var out = {};
+    if (!overrides) { return out; }
+    Object.keys(t.classes).forEach(function (name) {
+      var dot = name.indexOf('.');
+      var merged = {}, any = false;
+      var parent = dot > 0 ? overrides[name.slice(0, dot)] : null;
+      [parent, overrides[name]].forEach(function (o) { if (o) { Object.keys(o).forEach(function (f) { merged[f] = o[f]; any = true; }); } });
+      if (any) { out[name] = merged; }
+    });
+    return out;
+  }
+
+  /**
+   * The style with basemap overrides applied (contract §1 and §10): a copy, the input is never changed. `table` is
+   * the class table (default: the one bundled, equal to shared/basemap-classes.json). Layers of the table the style
+   * lacks are skipped; an unknown class or field throws.
+   */
+  function applyBasemapOverrides(style, overrides, table) {
+    var t = classTable(table);
+    var eff = effectiveOverrides(overrides, table);
+    var out = JSON.parse(JSON.stringify(style || {}));
+    if (!Object.keys(eff).length || !Array.isArray(out.layers)) { return out; }
+    var byId = {};
+    out.layers.forEach(function (l) { byId[l.id] = l; });
+    Object.keys(eff).forEach(function (name) {
+      t.classes[name].forEach(function (lr) {
+        var layer = byId[lr[0]];
+        if (layer) { applyToLayer(layer, lr[1], eff[name], t.paint); }
+      });
+    });
+    return out;
+  }
+
+  /** layer id → {class, role} for every basemap layer of the table. */
+  function basemapLayerIndex(table) {
+    var t = classTable(table), idx = {};
+    Object.keys(t.classes).forEach(function (name) {
+      t.classes[name].forEach(function (lr) { idx[lr[0]] = { 'class': name, role: lr[1] }; });
+    });
+    return idx;
+  }
+
+  // ------------------------------------------------------------------ slots (M25)
+
+  var SLOTS = ['bottom', 'roads', 'labels', 'top'];
+
+  /**
+   * Where each slot begins in a basemap's layer list (ids bottom to top): the id of the basemap layer a layer of that
+   * slot is drawn under, or undefined for the very top.
+   *   labels: the first label layer (classes labels.* and pois)
+   *   roads:  the first road layer (classes roads.* and rail), else labels
+   *   bottom: the layer after the last layer of land, landcover and water, else roads (never above roads)
+   *   top:    undefined
+   * Stable when the basemap's list changes: it is found from the classes, never from a position.
+   */
+  function slotAnchors(layerIds, table) {
+    var idx = basemapLayerIndex(table);
+    var cls = function (id) { return idx[id] && idx[id]['class']; };
+    var first = function (test) { for (var i = 0; i < layerIds.length; i++) { var c = cls(layerIds[i]); if (c && test(c)) { return i; } } return -1; };
+    var labels = first(function (c) { return c.indexOf('labels.') === 0 || c === 'pois'; });
+    var roads = first(function (c) { return c.indexOf('roads.') === 0 || c === 'rail'; });
+    if (roads < 0 || (labels >= 0 && roads > labels)) { roads = labels; }
+    var lastGround = -1;
+    for (var i = 0; i < layerIds.length; i++) { var c = cls(layerIds[i]); if (c === 'land' || c === 'landcover' || c === 'water') { lastGround = i; } }
+    var bottom = lastGround >= 0 && lastGround + 1 < layerIds.length ? lastGround + 1 : roads;
+    if (roads >= 0 && (bottom < 0 || bottom > roads)) { bottom = roads; }
+    var id = function (i) { return i >= 0 ? layerIds[i] : undefined; };
+    return { bottom: id(bottom), roads: id(roads), labels: id(labels), top: undefined };
+  }
+
+  // ------------------------------------------------------------------ bytes, text, inflate
+
+  function toBytes(input) {
+    if (input instanceof Uint8Array) { return input; }
+    if (typeof ArrayBuffer !== 'undefined' && input instanceof ArrayBuffer) { return new Uint8Array(input); }
+    if (input && input.buffer instanceof ArrayBuffer && typeof input.byteLength === 'number') { return new Uint8Array(input.buffer, input.byteOffset || 0, input.byteLength); }
+    if (input && typeof input.length === 'number' && typeof input !== 'string') { return Uint8Array.from(input); }
+    return null;
+  }
+
+  function utf8(bytes) {
+    if (typeof TextDecoder !== 'undefined') { return new TextDecoder('utf-8').decode(bytes); }
+    var s = '';
+    for (var i = 0; i < bytes.length; i++) { s += String.fromCharCode(bytes[i]); }
+    return decodeURIComponent(escape(s));
+  }
+
+  function stripBom(s) { return s.charCodeAt(0) === 0xfeff ? s.slice(1) : s; }
+
+  var LBASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+  var LEXT = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+  var DBASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+  var DEXT = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+  var CLORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+
+  function huffman(lengths) {
+    var count = new Uint16Array(16), offs = new Uint16Array(16), symbol = new Uint16Array(lengths.length);
+    for (var s = 0; s < lengths.length; s++) { count[lengths[s]]++; }
+    count[0] = 0;
+    for (var len = 1; len < 15; len++) { offs[len + 1] = offs[len] + count[len]; }
+    for (s = 0; s < lengths.length; s++) { if (lengths[s]) { symbol[offs[lengths[s]]++] = s; } }
+    return { count: count, symbol: symbol };
+  }
+
+  /** Raw DEFLATE (RFC 1951) → bytes. Small and synchronous, for KMZ, gzip and PMTiles directories. */
+  function inflateRaw(src) {
+    src = toBytes(src);
+    var pos = 0, bitBuf = 0, bitCnt = 0, out = new Uint8Array(Math.max(1024, src.length * 4)), n = 0;
+    function need(k) { if (n + k > out.length) { var b = new Uint8Array(Math.max(out.length * 2, n + k)); b.set(out.subarray(0, n)); out = b; } }
+    function bits(k) {
+      while (bitCnt < k) { if (pos >= src.length) { throw new Error('sMap: compressed data ends early'); } bitBuf |= src[pos++] << bitCnt; bitCnt += 8; }
+      var v = bitBuf & ((1 << k) - 1);
+      bitBuf >>>= k; bitCnt -= k;
+      return v;
+    }
+    function decode(h) {
+      var code = 0, first = 0, index = 0;
+      for (var len = 1; len < 16; len++) {
+        code |= bits(1);
+        var c = h.count[len];
+        if (code - first < c) { return h.symbol[index + code - first]; }
+        index += c; first += c; first <<= 1; code <<= 1;
+      }
+      throw new Error('sMap: bad compressed data');
+    }
+    var fixedLit = null, fixedDist = null;
+    var last;
+    do {
+      last = bits(1);
+      var type = bits(2);
+      if (type === 0) {
+        bitBuf = 0; bitCnt = 0;
+        if (pos + 4 > src.length) { throw new Error('sMap: compressed data ends early'); }
+        var len = src[pos] | (src[pos + 1] << 8);
+        pos += 4;
+        if (pos + len > src.length) { throw new Error('sMap: compressed data ends early'); }
+        need(len); out.set(src.subarray(pos, pos + len), n); n += len; pos += len;
+        continue;
+      }
+      var lit, dist;
+      if (type === 1) {
+        if (!fixedLit) {
+          var l = new Uint8Array(288);
+          for (var i = 0; i < 288; i++) { l[i] = i < 144 ? 8 : i < 256 ? 9 : i < 280 ? 7 : 8; }
+          fixedLit = huffman(l);
+          var d = new Uint8Array(30); d.fill(5); fixedDist = huffman(d);
+        }
+        lit = fixedLit; dist = fixedDist;
+      } else if (type === 2) {
+        var hlit = bits(5) + 257, hdist = bits(5) + 1, hclen = bits(4) + 4;
+        var cl = new Uint8Array(19);
+        for (i = 0; i < hclen; i++) { cl[CLORDER[i]] = bits(3); }
+        var clh = huffman(cl);
+        var lengths = new Uint8Array(hlit + hdist);
+        for (i = 0; i < hlit + hdist;) {
+          var sym = decode(clh);
+          if (sym < 16) { lengths[i++] = sym; continue; }
+          var rep, val = 0;
+          if (sym === 16) { if (i === 0) { throw new Error('sMap: bad compressed data'); } val = lengths[i - 1]; rep = 3 + bits(2); } else if (sym === 17) { rep = 3 + bits(3); } else { rep = 11 + bits(7); }
+          if (i + rep > hlit + hdist) { throw new Error('sMap: bad compressed data'); }
+          while (rep--) { lengths[i++] = val; }
+        }
+        lit = huffman(lengths.subarray(0, hlit)); dist = huffman(lengths.subarray(hlit));
+      } else { throw new Error('sMap: bad compressed data'); }
+      for (;;) {
+        var s = decode(lit);
+        if (s < 256) { need(1); out[n++] = s; continue; }
+        if (s === 256) { break; }
+        s -= 257;
+        if (s >= 29) { throw new Error('sMap: bad compressed data'); }
+        var length = LBASE[s] + bits(LEXT[s]);
+        var ds = decode(dist);
+        if (ds >= 30) { throw new Error('sMap: bad compressed data'); }
+        var back = DBASE[ds] + bits(DEXT[ds]);
+        if (back > n) { throw new Error('sMap: bad compressed data'); }
+        need(length);
+        for (var k = 0; k < length; k++) { out[n] = out[n - back]; n++; }
+      }
+    } while (!last);
+    return out.slice(0, n);
+  }
+
+  /** gzip (RFC 1952) → bytes; bytes that are not gzip are returned as they are. */
+  function gunzip(bytes) {
+    bytes = toBytes(bytes);
+    if (bytes.length < 18 || bytes[0] !== 0x1f || bytes[1] !== 0x8b) { return bytes; }
+    if (bytes[2] !== 8) { throw new Error('sMap: unsupported gzip method'); }
+    var flags = bytes[3], p = 10;
+    if (flags & 4) { p += 2 + (bytes[p] | (bytes[p + 1] << 8)); }
+    if (flags & 8) { while (bytes[p++] !== 0) { /* name */ } }
+    if (flags & 16) { while (bytes[p++] !== 0) { /* comment */ } }
+    if (flags & 2) { p += 2; }
+    return inflateRaw(bytes.subarray(p));
+  }
+
+  /** The files of a ZIP archive: [{name, bytes()}] (stored and deflated entries). */
+  function unzip(bytes) {
+    bytes = toBytes(bytes);
+    var dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    var e = -1;
+    for (var i = bytes.length - 22; i >= Math.max(0, bytes.length - 65557); i--) { if (dv.getUint32(i, true) === 0x06054b50) { e = i; break; } }
+    if (e < 0) { throw new Error('sMap: not a ZIP archive'); }
+    var count = dv.getUint16(e + 10, true), p = dv.getUint32(e + 16, true), files = [];
+    for (var k = 0; k < count; k++) {
+      if (dv.getUint32(p, true) !== 0x02014b50) { throw new Error('sMap: bad ZIP directory'); }
+      var method = dv.getUint16(p + 10, true), size = dv.getUint32(p + 20, true);
+      var nameLen = dv.getUint16(p + 28, true), extraLen = dv.getUint16(p + 30, true), commentLen = dv.getUint16(p + 32, true);
+      var local = dv.getUint32(p + 42, true);
+      var name = utf8(bytes.subarray(p + 46, p + 46 + nameLen));
+      p += 46 + nameLen + extraLen + commentLen;
+      (function (method, size, local, name) {
+        files.push({
+          name: name,
+          bytes: function () {
+            var start = local + 30 + dv.getUint16(local + 26, true) + dv.getUint16(local + 28, true);
+            var raw = bytes.subarray(start, start + size);
+            if (method === 0) { return raw; }
+            if (method === 8) { return inflateRaw(raw); }
+            throw new Error('sMap: unsupported ZIP method ' + method + ' for ' + name);
+          },
+        });
+      })(method, size, local, name);
+    }
+    return files;
+  }
+
+  // ------------------------------------------------------------------ XML (enough for KML, GPX, WMTS capabilities)
+
+  var ENTITIES = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+  function decodeEntities(s) {
+    return s.indexOf('&') < 0 ? s : s.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, function (m, e) {
+      if (e[0] === '#') { var cp = e[1] === 'x' || e[1] === 'X' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10); return isFinite(cp) ? String.fromCodePoint(cp) : m; }
+      return ENTITIES[e] !== undefined ? ENTITIES[e] : m;
+    });
+  }
+
+  /** A small XML reader: elements {name, local, attrs, children} where children holds elements and strings. */
+  function parseXml(s) {
+    var doc = { name: '#document', local: '#document', attrs: {}, children: [] }, stack = [doc], i = 0, n = s.length;
+    var top = function () { return stack[stack.length - 1]; };
+    while (i < n) {
+      var lt = s.indexOf('<', i);
+      if (lt < 0) { top().children.push(decodeEntities(s.slice(i))); break; }
+      if (lt > i) { top().children.push(decodeEntities(s.slice(i, lt))); }
+      var end;
+      if (s.startsWith('<!--', lt)) { end = s.indexOf('-->', lt + 4); i = end < 0 ? n : end + 3; continue; }
+      if (s.startsWith('<![CDATA[', lt)) { end = s.indexOf(']]>', lt + 9); top().children.push(s.slice(lt + 9, end < 0 ? n : end)); i = end < 0 ? n : end + 3; continue; }
+      if (s[lt + 1] === '?') { end = s.indexOf('?>', lt + 2); i = end < 0 ? n : end + 2; continue; }
+      if (s[lt + 1] === '!') {
+        var depth = 0, j = lt + 2;
+        for (; j < n; j++) { if (s[j] === '[') { depth++; } else if (s[j] === ']') { depth--; } else if (s[j] === '>' && depth <= 0) { break; } }
+        i = j + 1; continue;
+      }
+      if (s[lt + 1] === '/') {
+        end = s.indexOf('>', lt);
+        var closing = s.slice(lt + 2, end < 0 ? n : end).trim();
+        for (var k = stack.length - 1; k > 0; k--) { if (stack[k].name === closing) { stack.length = k; break; } }
+        i = end < 0 ? n : end + 1; continue;
+      }
+      var q = null, p = lt + 1;
+      for (; p < n; p++) { var c = s[p]; if (q) { if (c === q) { q = null; } } else if (c === '"' || c === "'") { q = c; } else if (c === '>') { break; } }
+      var body = s.slice(lt + 1, p), selfClose = /\/\s*$/.test(body);
+      if (selfClose) { body = body.replace(/\/\s*$/, ''); }
+      var m = /^([^\s/>]+)/.exec(body);
+      if (!m) { i = p + 1; continue; }
+      var attrs = {}, re = /([^\s=]+)\s*=\s*("([^"]*)"|'([^']*)')/g, a;
+      var rest = body.slice(m[1].length);
+      while ((a = re.exec(rest))) { attrs[a[1]] = decodeEntities(a[3] !== undefined ? a[3] : a[4]); }
+      var el = { name: m[1], local: m[1].replace(/^.*:/, ''), attrs: attrs, children: [] };
+      top().children.push(el);
+      if (!selfClose) { stack.push(el); }
+      i = p + 1;
+    }
+    return doc;
+  }
+
+  function elems(el, local) { var out = []; if (el) { el.children.forEach(function (c) { if (typeof c !== 'string' && (!local || c.local === local)) { out.push(c); } }); } return out; }
+  function elem(el, local) { return elems(el, local)[0] || null; }
+  function textOf(el) {
+    if (!el) { return ''; }
+    var s = '';
+    el.children.forEach(function (c) { s += typeof c === 'string' ? c : textOf(c); });
+    return s;
+  }
+  function trimmed(el) { return textOf(el).trim(); }
+  function descendants(el, local, out) {
+    out = out || [];
+    elems(el).forEach(function (c) { if (c.local === local) { out.push(c); } descendants(c, local, out); });
+    return out;
+  }
+  function attr(el, local) {
+    if (!el) { return undefined; }
+    for (var k in el.attrs) { if (k === local || k.replace(/^.*:/, '') === local) { return el.attrs[k]; } }
+    return undefined;
+  }
+
+  // ------------------------------------------------------------------ formats: read
+
+  var FORMATS = ['kml', 'kmz', 'gpx', 'polyline', 'polyline6', 'wkt', 'wkb', 'csv', 'topojson', 'geojson'];
+  var GEOMETRY_TYPES = ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'];
+
+  function fc(features) { return { type: 'FeatureCollection', features: features }; }
+  function feature(properties, geometry, id) {
+    var f = { type: 'Feature' };
+    if (id !== undefined && id !== null) { f.id = id; }
+    f.properties = properties || {};
+    f.geometry = geometry || null;
+    return f;
+  }
+
+  // KML colour aabbggrr → ['#rrggbb', opacity rounded to 2 decimals]
+  function kmlColor(v) {
+    v = String(v || '').trim().replace(/^#/, '');
+    if (!/^[0-9a-fA-F]{8}$/.test(v)) { return null; }
+    v = v.toLowerCase();
+    return ['#' + v.slice(6, 8) + v.slice(4, 6) + v.slice(2, 4), Math.round(parseInt(v.slice(0, 2), 16) / 255 * 100) / 100];
+  }
+
+  // Tuples are separated by white space that is not next to a comma ("-79.38, 43.65" is one tuple).
+  function kmlCoords(text) {
+    var out = [];
+    String(text).replace(/\s*,\s*/g, ',').trim().split(/\s+/).forEach(function (tuple) {
+      if (!tuple) { return; }
+      var p = tuple.split(',').map(Number);
+      if (p.length < 2 || !isFinite(p[0]) || !isFinite(p[1])) { return; }
+      out.push(p.length >= 3 && isFinite(p[2]) ? [p[0], p[1], p[2]] : [p[0], p[1]]);
+    });
+    return out;
+  }
+
+  function kmlGeometry(el) {
+    switch (el.local) {
+      case 'Point': { var c = kmlCoords(trimmed(elem(el, 'coordinates'))); return c.length ? { type: 'Point', coordinates: c[0] } : null; }
+      case 'LineString': case 'LinearRing': { var l = kmlCoords(trimmed(elem(el, 'coordinates'))); return l.length ? { type: 'LineString', coordinates: l } : null; }
+      case 'Polygon': {
+        var rings = [];
+        var ring = function (b) { var r = elem(b, 'LinearRing'); var cs = r ? kmlCoords(trimmed(elem(r, 'coordinates'))) : []; if (cs.length) { rings.push(cs); } };
+        elems(el, 'outerBoundaryIs').forEach(ring);
+        if (!rings.length) { return null; }
+        elems(el, 'innerBoundaryIs').forEach(ring);
+        return { type: 'Polygon', coordinates: rings };
+      }
+      case 'Track': {
+        var t = elems(el, 'coord').map(function (x) { var p = trimmed(x).split(/\s+/).map(Number); return p.length >= 3 && isFinite(p[2]) ? [p[0], p[1], p[2]] : [p[0], p[1]]; })
+          .filter(function (p) { return isFinite(p[0]) && isFinite(p[1]); });
+        return t.length ? { type: 'LineString', coordinates: t } : null;
+      }
+      case 'MultiTrack': {
+        var lines = elems(el, 'Track').map(kmlGeometry).filter(Boolean).map(function (g) { return g.coordinates; });
+        return lines.length ? { type: 'MultiLineString', coordinates: lines } : null;
+      }
+      case 'MultiGeometry': {
+        var parts = elems(el).map(function (c) { return GEOMETRY_ELEMENTS.indexOf(c.local) >= 0 ? kmlGeometry(c) : null; }).filter(Boolean);
+        return combine(parts);
+      }
+    }
+    return null;
+  }
+  var GEOMETRY_ELEMENTS = ['Point', 'LineString', 'LinearRing', 'Polygon', 'MultiGeometry', 'Track', 'MultiTrack'];
+
+  // Parts of one feature: one part is itself; parts all Point / LineString / Polygon → Multi*; anything else a collection.
+  function combine(parts) {
+    if (!parts.length) { return null; }
+    if (parts.length === 1) { return parts[0]; }
+    var t = parts[0].type;
+    var same = parts.every(function (g) { return g.type === t; });
+    if (same && (t === 'Point' || t === 'LineString' || t === 'Polygon')) {
+      return { type: 'Multi' + t, coordinates: parts.map(function (g) { return g.coordinates; }) };
+    }
+    return { type: 'GeometryCollection', geometries: parts };
+  }
+
+  function kmlStyleProps(style) {
+    var props = {};
+    if (!style) { return props; }
+    var icon = elem(style, 'IconStyle'), line = elem(style, 'LineStyle'), poly = elem(style, 'PolyStyle');
+    var c;
+    if (icon && (c = kmlColor(trimmed(elem(icon, 'color'))))) { props['marker-color'] = c[0]; }
+    if (line) {
+      if ((c = kmlColor(trimmed(elem(line, 'color'))))) { props.stroke = c[0]; props['stroke-opacity'] = c[1]; }
+      var w = parseFloat(trimmed(elem(line, 'width')));
+      if (isFinite(w)) { props['stroke-width'] = w; }
+    }
+    if (poly) {
+      if ((c = kmlColor(trimmed(elem(poly, 'color'))))) { props.fill = c[0]; props['fill-opacity'] = c[1]; }
+      if (trimmed(elem(poly, 'fill')) === '0') { props['fill-opacity'] = 0; }
+      if (trimmed(elem(poly, 'outline')) === '0') { props['stroke-opacity'] = 0; }
+    }
+    return props;
+  }
+
+  function readKml(text) {
+    var doc = parseXml(stripBom(text));
+    var styles = {}, maps = {};
+    descendants(doc, 'Style').forEach(function (s) { if (s.attrs.id) { styles[s.attrs.id] = s; } });
+    descendants(doc, 'StyleMap').forEach(function (s) {
+      if (!s.attrs.id) { return; }
+      elems(s, 'Pair').forEach(function (p) { if (trimmed(elem(p, 'key')) === 'normal') { maps[s.attrs.id] = trimmed(elem(p, 'styleUrl')); } });
+    });
+    var resolve = function (url, depth) {
+      var id = String(url || '').replace(/^[^#]*#/, '');
+      if (styles[id]) { return styles[id]; }
+      if (maps[id] && depth < 4) { return resolve(maps[id], depth + 1); }
+      return null;
+    };
+    var features = descendants(doc, 'Placemark').map(function (pm) {
+      var props = {};
+      var name = elem(pm, 'name'), desc = elem(pm, 'description');
+      if (name) { props.name = trimmed(name); }
+      if (desc) { props.description = trimmed(desc); }
+      var ext = elem(pm, 'ExtendedData');
+      if (ext) {
+        elems(ext, 'Data').forEach(function (d) { if (d.attrs.name !== undefined) { props[d.attrs.name] = trimmed(elem(d, 'value')); } });
+        elems(ext, 'SchemaData').forEach(function (sd) { elems(sd, 'SimpleData').forEach(function (d) { if (d.attrs.name !== undefined) { props[d.attrs.name] = trimmed(d); } }); });
+      }
+      var style = {};
+      var url = elem(pm, 'styleUrl');
+      if (url) { Object.assign(style, kmlStyleProps(resolve(trimmed(url), 0))); }
+      var inline = elem(pm, 'Style');
+      if (inline) { Object.assign(style, kmlStyleProps(inline)); }
+      ['marker-color', 'stroke', 'stroke-opacity', 'stroke-width', 'fill', 'fill-opacity'].forEach(function (k) { if (style[k] !== undefined) { props[k] = style[k]; } });
+      var geomEl = elems(pm).filter(function (c) { return GEOMETRY_ELEMENTS.indexOf(c.local) >= 0; });
+      return feature(props, combine(geomEl.map(kmlGeometry).filter(Boolean)));
+    });
+    return fc(features);
+  }
+
+  function readKmz(bytes) {
+    var files = unzip(bytes).filter(function (f) { return /\.kml$/i.test(f.name); });
+    if (!files.length) { throw new Error('sMap: the KMZ file holds no KML document'); }
+    var main = files.filter(function (f) { return /(^|\/)doc\.kml$/i.test(f.name); })[0]
+      || files.filter(function (f) { return f.name.indexOf('/') < 0; })[0] || files[0];
+    return readKml(utf8(main.bytes()));
+  }
+
+  var GPX_SKIP = ['ele', 'extensions', 'link', 'rtept', 'trkseg', 'trkpt'];
+  function gpxProps(el) {
+    var props = {};
+    elems(el).forEach(function (c) {
+      if (GPX_SKIP.indexOf(c.local) >= 0 || elems(c).length) { return; }
+      props[c.local] = trimmed(c);
+    });
+    return props;
+  }
+  function gpxPoint(pt) {
+    var lon = parseFloat(pt.attrs.lon), lat = parseFloat(pt.attrs.lat);
+    if (!isFinite(lon) || !isFinite(lat)) { return null; }
+    var ele = parseFloat(trimmed(elem(pt, 'ele')));
+    return isFinite(ele) && elem(pt, 'ele') ? [lon, lat, ele] : [lon, lat];
+  }
+
+  function readGpx(text) {
+    var doc = parseXml(stripBom(text));
+    var gpx = descendants(doc, 'gpx')[0];
+    if (!gpx) { throw new Error('sMap: not a GPX document'); }
+    var features = [];
+    elems(gpx).forEach(function (el) {
+      if (el.local === 'wpt') {
+        var p = gpxPoint(el);
+        if (p) { features.push(feature(gpxProps(el), { type: 'Point', coordinates: p })); }
+      } else if (el.local === 'rte') {
+        var r = elems(el, 'rtept').map(gpxPoint).filter(Boolean);
+        if (r.length) { features.push(feature(gpxProps(el), { type: 'LineString', coordinates: r })); }
+      } else if (el.local === 'trk') {
+        var segs = elems(el, 'trkseg').map(function (s) { return elems(s, 'trkpt').map(gpxPoint).filter(Boolean); }).filter(function (s) { return s.length; });
+        if (segs.length === 1) { features.push(feature(gpxProps(el), { type: 'LineString', coordinates: segs[0] })); }
+        else if (segs.length > 1) { features.push(feature(gpxProps(el), { type: 'MultiLineString', coordinates: segs })); }
+      }
+    });
+    return fc(features);
+  }
+
+  /** Decodes an encoded polyline (precision 5: Google, OSRM; 6: Valhalla) to [[lng, lat], …]. */
+  function decodePolyline(str, precision) {
+    var factor = Math.pow(10, precision === undefined ? 5 : precision);
+    str = String(str).trim();
+    var i = 0, lat = 0, lng = 0, out = [];
+    var next = function () {
+      var result = 0, shift = 1, b;
+      do {
+        if (i >= str.length) { throw new Error('sMap: the polyline ends early'); }
+        b = str.charCodeAt(i++) - 63;
+        if (b < 0 || b > 63) { throw new Error('sMap: not an encoded polyline'); }
+        result += (b & 0x1f) * shift;
+        shift *= 32;
+      } while (b >= 0x20);
+      return result % 2 ? -(result + 1) / 2 : result / 2;
+    };
+    while (i < str.length) {
+      lat += next();
+      lng += next();
+      out.push([lng / factor, lat / factor]);
+    }
+    return out;
+  }
+
+  /** Encodes [[lng, lat], …] as a polyline. */
+  function encodePolyline(coords, precision) {
+    var factor = Math.pow(10, precision === undefined ? 5 : precision);
+    var out = '', plat = 0, plng = 0;
+    var enc = function (v) {
+      var n = v < 0 ? -2 * v - 1 : 2 * v;
+      while (n >= 32) { out += String.fromCharCode((32 | (n % 32)) + 63); n = Math.floor(n / 32); }
+      out += String.fromCharCode(n + 63);
+    };
+    coords.forEach(function (c) {
+      var lat = Math.round(c[1] * factor), lng = Math.round(c[0] * factor);
+      enc(lat - plat); enc(lng - plng);
+      plat = lat; plng = lng;
+    });
+    return out;
+  }
+
+  function readPolyline(text, precision) {
+    var c = decodePolyline(text, precision);
+    return fc(c.length ? [feature({}, { type: 'LineString', coordinates: c })] : []);
+  }
+
+  // WKT: one or more geometries, separated by white space, commas, semicolons or new lines.
+  function readWkt(text) {
+    var s = String(text), i = 0, features = [];
+    var ws = function () { while (i < s.length && /[\s,;]/.test(s[i])) { i++; } };
+    var spaces = function () { while (i < s.length && /\s/.test(s[i])) { i++; } };
+    var word = function () { spaces(); var m = /^[A-Za-z]+/.exec(s.slice(i)); if (!m) { return ''; } i += m[0].length; return m[0].toUpperCase(); };
+    var expect = function (c) { spaces(); if (s[i] !== c) { throw new Error('sMap: WKT: "' + c + '" expected at ' + i); } i++; };
+    var peek = function () { spaces(); return s[i]; };
+    var dims = { z: false, m: false };
+    var point = function () {
+      var nums = [];
+      for (;;) {
+        spaces();
+        var m = /^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?/.exec(s.slice(i));
+        if (!m) { break; }
+        nums.push(Number(m[0])); i += m[0].length;
+      }
+      if (nums.length < 2) { throw new Error('sMap: WKT: a position needs two numbers at ' + i); }
+      var hasZ = dims.z || (!dims.m && nums.length >= 3);
+      return hasZ && nums.length >= 3 ? [nums[0], nums[1], nums[2]] : [nums[0], nums[1]];
+    };
+    var list = function (item) {
+      expect('(');
+      var out = [item()];
+      while (peek() === ',') { i++; out.push(item()); }
+      expect(')');
+      return out;
+    };
+    var empty = function () { var save = i; if (word() === 'EMPTY') { return true; } i = save; return false; };
+    var geometry = function () {
+      spaces();
+      var m = /^SRID=\d+;/i.exec(s.slice(i));
+      if (m) { i += m[0].length; }
+      var type = word();
+      if (!type) { throw new Error('sMap: WKT: a geometry type expected at ' + i); }
+      var flag = null;
+      // The flag may be glued to the type: POINTZ, LINESTRINGM, POLYGONZM are POINT Z, LINESTRING M, POLYGON ZM.
+      var glued = /^(POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)(ZM|Z|M)$/.exec(type);
+      if (glued) { type = glued[1]; flag = glued[2]; } else {
+        var save = i;
+        flag = word();
+        if (flag !== 'Z' && flag !== 'M' && flag !== 'ZM') { i = save; flag = null; }
+      }
+      dims = { z: flag === 'Z' || flag === 'ZM', m: flag === 'M' || flag === 'ZM' };
+      if (empty()) { return null; }
+      var ring = function () { return list(point); };
+      switch (type) {
+        case 'POINT': return { type: 'Point', coordinates: list(point)[0] };
+        case 'LINESTRING': return { type: 'LineString', coordinates: list(point) };
+        case 'POLYGON': return { type: 'Polygon', coordinates: list(ring) };
+        case 'MULTIPOINT': return { type: 'MultiPoint', coordinates: list(function () { if (peek() === '(') { return list(point)[0]; } return point(); }) };
+        case 'MULTILINESTRING': return { type: 'MultiLineString', coordinates: list(ring) };
+        case 'MULTIPOLYGON': return { type: 'MultiPolygon', coordinates: list(function () { return list(ring); }) };
+        case 'GEOMETRYCOLLECTION': {
+          var outer = dims;
+          var g = list(function () { var x = geometry(); dims = outer; return x; }).filter(Boolean);
+          return { type: 'GeometryCollection', geometries: g };
+        }
+      }
+      throw new Error('sMap: WKT: unknown geometry type ' + type);
+    };
+    ws();
+    while (i < s.length) { features.push(feature({}, geometry())); ws(); }
+    return fc(features);
+  }
+
+  function readWkbGeometry(bytes, at) {
+    var dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), p = at.p;
+    var little = bytes[p] === 1; p += 1;
+    var raw = dv.getUint32(p, little); p += 4;
+    var z = !!(raw & 0x80000000), m = !!(raw & 0x40000000);
+    if (raw & 0x20000000) { p += 4; }
+    var type = raw & 0x0fffffff;
+    if (type >= 1000) { var k = Math.floor(type / 1000); z = z || k === 1 || k === 3; m = m || k === 2 || k === 3; type %= 1000; }
+    var dims = 2 + (z ? 1 : 0) + (m ? 1 : 0);
+    var pos = function () {
+      var c = [dv.getFloat64(p, little), dv.getFloat64(p + 8, little)];
+      if (z) { c.push(dv.getFloat64(p + 16, little)); }
+      p += 8 * dims;
+      return c;
+    };
+    var u32 = function () { var v = dv.getUint32(p, little); p += 4; return v; };
+    var seq = function () { var n = u32(), out = []; for (var i = 0; i < n; i++) { out.push(pos()); } return out; };
+    var parts = function () { var n = u32(), out = []; at.p = p; for (var i = 0; i < n; i++) { out.push(readWkbGeometry(bytes, at)); } p = at.p; return out; };
+    var g;
+    switch (type) {
+      case 1: { var c = pos(); g = c.every(function (v) { return isNaN(v); }) ? null : { type: 'Point', coordinates: c }; break; }
+      case 2: g = { type: 'LineString', coordinates: seq() }; break;
+      case 3: { var n = u32(), rings = []; for (var r = 0; r < n; r++) { rings.push(seq()); } g = { type: 'Polygon', coordinates: rings }; break; }
+      case 4: g = { type: 'MultiPoint', coordinates: parts().filter(Boolean).map(function (x) { return x.coordinates; }) }; break;
+      case 5: g = { type: 'MultiLineString', coordinates: parts().filter(Boolean).map(function (x) { return x.coordinates; }) }; break;
+      case 6: g = { type: 'MultiPolygon', coordinates: parts().filter(Boolean).map(function (x) { return x.coordinates; }) }; break;
+      case 7: g = { type: 'GeometryCollection', geometries: parts().filter(Boolean) }; break;
+      default: throw new Error('sMap: WKB: unknown geometry type ' + type);
+    }
+    if (g && g.type !== 'Point' && g.type !== 'GeometryCollection' && g.coordinates.length === 0) { g = null; }
+    if (g && g.type === 'GeometryCollection' && g.geometries.length === 0) { g = null; }
+    at.p = p;
+    return g;
+  }
+
+  // WKB or EWKB: bytes, or hex text (one geometry per line; a leading \x is allowed).
+  function readWkb(input) {
+    var chunks = [];
+    if (typeof input === 'string') {
+      input.split(/\s+/).forEach(function (h) {
+        h = h.replace(/^\\x/i, '');
+        if (!h) { return; }
+        if (!/^[0-9a-fA-F]+$/.test(h) || h.length % 2) { throw new Error('sMap: WKB text must be hexadecimal'); }
+        var b = new Uint8Array(h.length / 2);
+        for (var i = 0; i < b.length; i++) { b[i] = parseInt(h.substr(i * 2, 2), 16); }
+        chunks.push(b);
+      });
+    } else { chunks.push(toBytes(input)); }
+    var features = [];
+    chunks.forEach(function (b) {
+      var at = { p: 0 };
+      while (at.p < b.length) { features.push(feature({}, readWkbGeometry(b, at))); }
+    });
+    return fc(features);
+  }
+
+  var LAT_HEADINGS = ['lat', 'latitude', 'y', 'lat_dd', 'latitude_dd', 'ycoord', 'y_coord', 'point_y', '纬度'];
+  var LNG_HEADINGS = ['lng', 'lon', 'long', 'longitude', 'x', 'lng_dd', 'lon_dd', 'longitude_dd', 'xcoord', 'x_coord', 'point_x', '经度'];
+
+  function csvRows(text, delim) {
+    var rows = [], row = [], field = '', q = false, i = 0, s = text;
+    for (; i < s.length; i++) {
+      var c = s[i];
+      if (q) {
+        if (c === '"') { if (s[i + 1] === '"') { field += '"'; i++; } else { q = false; } } else { field += c; }
+      } else if (c === '"' && field === '') { q = true; }
+      else if (c === delim) { row.push(field); field = ''; }
+      else if (c === '\n' || c === '\r') {
+        if (c === '\r' && s[i + 1] === '\n') { i++; }
+        row.push(field); field = ''; rows.push(row); row = [];
+      } else { field += c; }
+    }
+    if (field !== '' || row.length) { row.push(field); rows.push(row); }
+    return rows.filter(function (r) { return !(r.length === 1 && r[0].trim() === ''); });
+  }
+
+  function readCsv(text, o) {
+    text = stripBom(String(text));
+    var firstLine = text.split(/\r?\n/)[0] || '';
+    var delim = [',', ';', '\t', '|'].map(function (d) { return [d, firstLine.split(d).length]; }).sort(function (a, b) { return b[1] - a[1]; })[0][0];
+    var rows = csvRows(text, delim);
+    if (!rows.length) { return fc([]); }
+    var head = rows[0].map(function (h) { return h.trim(); });
+    var norm = head.map(function (h) { return h.toLowerCase().replace(/\s+/g, '_'); });
+    var find = function (given, candidates, what) {
+      if (given !== undefined && given !== null) {
+        var at = head.indexOf(String(given));
+        if (at < 0) { at = norm.indexOf(String(given).toLowerCase()); }
+        if (at < 0) { throw new Error('sMap: CSV has no column "' + given + '"'); }
+        return at;
+      }
+      for (var i = 0; i < candidates.length; i++) { var k = norm.indexOf(candidates[i]); if (k >= 0) { return k; } }
+      throw new Error('sMap: CSV: no ' + what + ' column found; name it with the ' + what + ' option');
+    };
+    var la = find(o.lat, LAT_HEADINGS, 'lat'), ln = find(o.lng, LNG_HEADINGS, 'lng');
+    // A coordinate is a whole number text (never a prefix of one); with ';' or tab delimiters a decimal comma counts.
+    var decimalComma = delim === ';' || delim === '\t';
+    var coord = function (v) {
+      v = (v === undefined ? '' : v).trim();
+      if (decimalComma && /^[-+]?\d*,\d+([eE][-+]?\d+)?$/.test(v)) { v = v.replace(',', '.'); }
+      return /^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(v) ? Number(v) : NaN;
+    };
+    var features = [];
+    for (var r = 1; r < rows.length; r++) {
+      var row = rows[r].map(function (cell) { return cell.trim(); });
+      var lat = coord(row[la]), lng = coord(row[ln]);
+      if (!isFinite(lat) || !isFinite(lng) || Math.abs(lat) > 90 || Math.abs(lng) > 180) { continue; }
+      var props = {};
+      for (var c = 0; c < head.length; c++) { if (c !== la && c !== ln) { props[head[c]] = row[c] !== undefined ? row[c] : ''; } }
+      features.push(feature(props, { type: 'Point', coordinates: [lng, lat] }));
+    }
+    return fc(features);
+  }
+
+  function readTopojson(topo) {
+    if (!topo || topo.type !== 'Topology') { throw new Error('sMap: not a TopoJSON topology'); }
+    var tr = topo.transform;
+    var kx = tr ? tr.scale[0] : 1, ky = tr ? tr.scale[1] : 1, dx = tr ? tr.translate[0] : 0, dy = tr ? tr.translate[1] : 0;
+    var arcs = (topo.arcs || []).map(function (arc) {
+      var x = 0, y = 0;
+      return arc.map(function (p) {
+        if (tr) { x += p[0]; y += p[1]; var q = [x * kx + dx, y * ky + dy]; return p.length > 2 ? q.concat(p.slice(2)) : q; }
+        return p.slice();
+      });
+    });
+    var arc = function (i) { return i < 0 ? arcs[~i].slice().reverse() : arcs[i]; };
+    var line = function (ids) {
+      var out = [];
+      ids.forEach(function (id) { var a = arc(id); out = out.concat(out.length ? a.slice(1) : a); });
+      return out;
+    };
+    var pt = function (p) { if (!tr) { return p.slice(); } var q = [p[0] * kx + dx, p[1] * ky + dy]; return p.length > 2 ? q.concat(p.slice(2)) : q; };
+    var geom = function (o) {
+      switch (o.type) {
+        case 'Point': return { type: 'Point', coordinates: pt(o.coordinates) };
+        case 'MultiPoint': return { type: 'MultiPoint', coordinates: o.coordinates.map(pt) };
+        case 'LineString': return { type: 'LineString', coordinates: line(o.arcs) };
+        case 'MultiLineString': return { type: 'MultiLineString', coordinates: o.arcs.map(line) };
+        case 'Polygon': return { type: 'Polygon', coordinates: o.arcs.map(line) };
+        case 'MultiPolygon': return { type: 'MultiPolygon', coordinates: o.arcs.map(function (p) { return p.map(line); }) };
+        case 'GeometryCollection': return { type: 'GeometryCollection', geometries: (o.geometries || []).map(geom).filter(Boolean) };
+      }
+      return null;
+    };
+    var features = [];
+    Object.keys(topo.objects || {}).forEach(function (name) {
+      var o = topo.objects[name];
+      var list = o.type === 'GeometryCollection' ? o.geometries || [] : [o];
+      list.forEach(function (g) { features.push(feature(g.properties ? JSON.parse(JSON.stringify(g.properties)) : {}, geom(g), g.id)); });
+    });
+    return fc(features);
+  }
+
+  function readGeojson(data) {
+    if (!data) { return fc([]); }
+    var norm = function (f) { return feature(f.properties || {}, f.geometry || null, f.id); };
+    if (data.type === 'FeatureCollection') { return fc((data.features || []).map(norm)); }
+    if (data.type === 'Feature') { return fc([norm(data)]); }
+    if (GEOMETRY_TYPES.indexOf(data.type) >= 0) { return fc([feature({}, data)]); }
+    throw new Error('sMap: not GeoJSON');
+  }
+
+  var EXTENSIONS = { kml: 'kml', kmz: 'kmz', gpx: 'gpx', wkt: 'wkt', wkb: 'wkb', csv: 'csv', tsv: 'csv', txt: null,
+    topojson: 'topojson', geojson: 'geojson', json: null, polyline: 'polyline', polyline6: 'polyline6' };
+
+  /** The format of a file name's extension, or null. */
+  function formatOfName(name) {
+    var m = /\.([A-Za-z0-9]+)$/.exec(String(name || ''));
+    return m && EXTENSIONS[m[1].toLowerCase()] ? EXTENSIONS[m[1].toLowerCase()] : null;
+  }
+
+  /** Guesses the format from the content: zip → kmz, XML root kml / gpx, JSON Topology / GeoJSON, WKT, hex WKB, CSV. */
+  function sniff(input) {
+    var bytes = typeof input === 'string' || (input && typeof input === 'object' && !toBytes(input)) ? null : toBytes(input);
+    if (bytes && bytes[0] === 0x50 && bytes[1] === 0x4b) { return 'kmz'; }
+    if (bytes && (bytes[0] === 0 || bytes[0] === 1) && bytes.length >= 21) { return 'wkb'; }
+    if (input && typeof input === 'object' && !bytes) { return input.type === 'Topology' ? 'topojson' : 'geojson'; }
+    var s = stripBom(bytes ? utf8(bytes) : String(input)).trim();
+    if (s[0] === '<') {
+      if (/<kml[\s>]/i.test(s)) { return 'kml'; }
+      if (/<gpx[\s>]/i.test(s)) { return 'gpx'; }
+      return null;
+    }
+    if (s[0] === '{') { return /"type"\s*:\s*"Topology"/.test(s) ? 'topojson' : 'geojson'; }
+    if (/^(SRID=\d+;)?\s*(POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)\b/i.test(s)) { return 'wkt'; }
+    if (/^(\\x)?0[01][0-9a-fA-F]{8}/.test(s) && /^[\s0-9a-fA-Fx\\]+$/.test(s)) { return 'wkb'; }
+    var first = s.split(/\r?\n/)[0].toLowerCase();
+    if (/[,;\t|]/.test(first) && LAT_HEADINGS.concat(LNG_HEADINGS).some(function (h) { return first.split(/[,;\t|]/).map(function (x) { return x.trim().replace(/^"|"$/g, '').replace(/\s+/g, '_'); }).indexOf(h) >= 0; })) { return 'csv'; }
+    return null;
+  }
+
+  /**
+   * Reads a file into a GeoJSON FeatureCollection, on the device (M29/M30).
+   * @param input  text, bytes (ArrayBuffer / Uint8Array), or a parsed JSON object (GeoJSON, TopoJSON)
+   * @param o      {format, lat, lng, name}: format one of FORMATS (guessed from `name`'s extension or the content when
+   *               omitted; polylines are never guessed); lat / lng name the CSV columns (guessed from common headings)
+   */
+  function read(input, o) {
+    o = o || {};
+    var format = o.format ? String(o.format).toLowerCase() : (formatOfName(o.name) || sniff(input));
+    if (!format) { throw new Error('sMap: the file format could not be recognised; pass {format}'); }
+    if (FORMATS.indexOf(format) < 0) { throw new Error('sMap: unknown format "' + format + '"'); }
+    var text = function () { if (typeof input === 'string') { return input; } var b = toBytes(input); if (!b) { throw new Error('sMap: ' + format + ' needs text or bytes'); } return utf8(b); };
+    var json = function () { return input && typeof input === 'object' && !toBytes(input) ? input : JSON.parse(stripBom(text())); };
+    switch (format) {
+      case 'kml': return readKml(text());
+      case 'kmz': { var b = toBytes(input); if (!b) { throw new Error('sMap: kmz needs bytes'); } return readKmz(b); }
+      case 'gpx': return readGpx(text());
+      case 'polyline': return readPolyline(text(), 5);
+      case 'polyline6': return readPolyline(text(), 6);
+      case 'wkt': return readWkt(text());
+      case 'wkb': return readWkb(typeof input === 'string' ? input : (toBytes(input) && /^[\s0-9a-fA-Fx\\]+$/.test(utf8(toBytes(input)).trim()) && toBytes(input)[0] !== 0 && toBytes(input)[0] !== 1 ? utf8(toBytes(input)).trim() : input));
+      case 'csv': return readCsv(text(), o);
+      case 'topojson': return readTopojson(json());
+      case 'geojson': return readGeojson(json());
+    }
+    return fc([]);
+  }
+
+  /** A Blob or File (or a fetch Response) read as `read` would: the format comes from the file name when not given. */
+  function readFile(file, o) {
+    o = Object.assign({}, o || {});
+    if (!o.name && file && file.name) { o.name = file.name; }
+    if (!o.name && file && file.url) { o.name = String(file.url).split('?')[0]; }
+    return Promise.resolve(file.arrayBuffer()).then(function (buf) { return read(new Uint8Array(buf), o); });
+  }
+
+  // ------------------------------------------------------------------ formats: write
+
+  function xmlEscape(v) { return String(v).replace(/[&<>"']/g, function (c) { return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' }[c]; }); }
+
+  // '#rgb' / '#rrggbb' + opacity → KML aabbggrr; anything else null.
+  function toKmlColor(color, opacity) {
+    var m = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.exec(String(color || '').trim());
+    if (!m) { return null; }
+    var h = m[1].length === 3 ? m[1].replace(/./g, '$&$&') : m[1];
+    var a = Math.round(Math.max(0, Math.min(1, opacity === undefined || opacity === null || opacity === '' ? 1 : Number(opacity))) * 255);
+    var aa = (a < 16 ? '0' : '') + a.toString(16);
+    return (aa + h.slice(4, 6) + h.slice(2, 4) + h.slice(0, 2)).toLowerCase();
+  }
+
+  var SIMPLESTYLE = ['marker-color', 'marker-size', 'marker-symbol', 'stroke', 'stroke-width', 'stroke-opacity', 'fill', 'fill-opacity', 'title', 'description'];
+
+  function kmlCoordText(c) { return c.map(function (p) { return p.slice(0, 3).join(','); }).join(' '); }
+  function kmlGeom(g) {
+    if (!g) { return ''; }
+    switch (g.type) {
+      case 'Point': return '<Point><coordinates>' + kmlCoordText([g.coordinates]) + '</coordinates></Point>';
+      case 'LineString': return '<LineString><coordinates>' + kmlCoordText(g.coordinates) + '</coordinates></LineString>';
+      case 'Polygon': return '<Polygon>' + g.coordinates.map(function (r, i) {
+        var tag = i === 0 ? 'outerBoundaryIs' : 'innerBoundaryIs';
+        return '<' + tag + '><LinearRing><coordinates>' + kmlCoordText(r) + '</coordinates></LinearRing></' + tag + '>';
+      }).join('') + '</Polygon>';
+      case 'MultiPoint': return '<MultiGeometry>' + g.coordinates.map(function (c) { return kmlGeom({ type: 'Point', coordinates: c }); }).join('') + '</MultiGeometry>';
+      case 'MultiLineString': return '<MultiGeometry>' + g.coordinates.map(function (c) { return kmlGeom({ type: 'LineString', coordinates: c }); }).join('') + '</MultiGeometry>';
+      case 'MultiPolygon': return '<MultiGeometry>' + g.coordinates.map(function (c) { return kmlGeom({ type: 'Polygon', coordinates: c }); }).join('') + '</MultiGeometry>';
+      case 'GeometryCollection': return '<MultiGeometry>' + g.geometries.map(kmlGeom).join('') + '</MultiGeometry>';
+    }
+    return '';
+  }
+
+  /**
+   * A FeatureCollection as a KML 2.2 document: one Placemark per feature (name from `name` or `title`, `description`,
+   * simplestyle properties as an inline Style, every other property as ExtendedData).
+   */
+  function writeKml(data, o) {
+    o = o || {};
+    var features = readGeojson(data).features;
+    var out = '<?xml version="1.0" encoding="UTF-8"?>\n<kml xmlns="http://www.opengis.net/kml/2.2"><Document>' +
+      (o.name ? '<name>' + xmlEscape(o.name) + '</name>' : '') + '\n';
+    features.forEach(function (f) {
+      var p = f.properties || {};
+      var name = p.name !== undefined && p.name !== null ? p.name : p.title;
+      var s = '<Placemark>';
+      if (name !== undefined && name !== null) { s += '<name>' + xmlEscape(name) + '</name>'; }
+      if (p.description !== undefined && p.description !== null) { s += '<description>' + xmlEscape(p.description) + '</description>'; }
+      var style = '';
+      var icon = toKmlColor(p['marker-color']);
+      if (icon) { style += '<IconStyle><color>' + icon + '</color></IconStyle>'; }
+      var line = toKmlColor(p.stroke || (p['stroke-opacity'] !== undefined || p['stroke-width'] !== undefined ? '#555555' : null), p['stroke-opacity']);
+      if (line || p['stroke-width'] !== undefined) {
+        style += '<LineStyle>' + (line ? '<color>' + line + '</color>' : '') + (p['stroke-width'] !== undefined ? '<width>' + Number(p['stroke-width']) + '</width>' : '') + '</LineStyle>';
+      }
+      var poly = toKmlColor(p.fill || (p['fill-opacity'] !== undefined ? '#555555' : null), p['fill-opacity']);
+      if (poly) { style += '<PolyStyle><color>' + poly + '</color></PolyStyle>'; }
+      if (style) { s += '<Style>' + style + '</Style>'; }
+      var extra = Object.keys(p).filter(function (k) { return k !== 'name' && SIMPLESTYLE.indexOf(k) < 0 && p[k] !== null && p[k] !== undefined; });
+      if (p.name !== undefined && p.name !== null && p.title !== undefined && p.title !== null) { extra.push('title'); }
+      if (extra.length) {
+        s += '<ExtendedData>' + extra.map(function (k) {
+          var v = p[k];
+          return '<Data name="' + xmlEscape(k) + '"><value>' + xmlEscape(typeof v === 'object' ? JSON.stringify(v) : v) + '</value></Data>';
+        }).join('') + '</ExtendedData>';
+      }
+      out += s + kmlGeom(f.geometry) + '</Placemark>\n';
+    });
+    return out + '</Document></kml>\n';
+  }
+
+  /** Writes a FeatureCollection as 'geojson' (text) or 'kml'. */
+  function write(data, format, o) {
+    format = String(format || 'geojson').toLowerCase();
+    if (format === 'geojson') { return JSON.stringify(readGeojson(data)); }
+    if (format === 'kml') { return writeKml(data, o); }
+    throw new Error('sMap: cannot write format "' + format + '" (geojson, kml)');
+  }
+
+  // ------------------------------------------------------------------ the converting endpoint (contract §6)
+
+  var CONVERT_LIMIT = 20 * 1024 * 1024;
+
+  /**
+   * Converts a file on sMap (`POST /v1/convert`, contract §6): for large files or formats a caller cannot parse.
+   * @param input   a Blob / File, bytes or text
+   * @param o       {format (guessed from the file name or content when omitted), lat, lng, baseUrl, apiKey, token}
+   * @returns Promise of a GeoJSON FeatureCollection
+   */
+  function convert(input, o) {
+    o = o || {};
+    if (typeof fetch === 'undefined') { return Promise.reject(new Error('sMap: convert needs fetch')); }
+    var base = String(o.baseUrl || DEFAULT_BASE).replace(/\/$/, '');
+    var bodyOf = input && typeof input.arrayBuffer === 'function' && !(input instanceof Uint8Array)
+      ? Promise.resolve(input.arrayBuffer()).then(function (b) { return new Uint8Array(b); })
+      : Promise.resolve(typeof input === 'string' ? input : toBytes(input));
+    return bodyOf.then(function (body) {
+      var size = typeof body === 'string' ? body.length : body.length;
+      if (size > CONVERT_LIMIT) { throw new Error('sMap: convert takes files of at most 20 MB'); }
+      var format = o.format ? String(o.format).toLowerCase() : (formatOfName(o.name || (input && input.name)) || sniff(body));
+      if (!format || FORMATS.indexOf(format) < 0) { throw new Error('sMap: the file format could not be recognised; pass {format}'); }
+      var url = base + '/v1/convert?from=' + encodeURIComponent(format);
+      if (o.lat) { url += '&lat=' + encodeURIComponent(o.lat); }
+      if (o.lng) { url += '&lng=' + encodeURIComponent(o.lng); }
+      var headers = { 'Content-Type': 'application/octet-stream' };
+      if (o.token) { headers.Authorization = 'Bearer ' + o.token; }
+      if (o.apiKey) { headers['X-SMap-Key'] = o.apiKey; }
+      return fetch(url, { method: 'POST', headers: headers, body: body }).then(function (res) {
+        if (!res.ok) {
+          return res.text().then(function (t) {
+            var msg = t;
+            try { var j = JSON.parse(t); msg = j.message || j.error || t; } catch (e) { /* plain text */ }
+            throw new Error('sMap: convert failed (HTTP ' + res.status + ')' + (msg ? ': ' + msg : ''));
+          });
+        }
+        return res.json();
+      });
+    });
+  }
+
+  // ------------------------------------------------------------------ URLs
+
+  function styleName(style) {
+    style = String(style || 'light');
+    if (FLAVORS.indexOf(style) >= 0 || /^custom:[A-Za-z0-9_-]+$/.test(style)) { return style; }
+    throw new Error('sMap: unknown style "' + style + '" (a scheme or custom:<id>)');
+  }
+
+  function query(o) {
+    var q = [];
+    if (o.lang) { q.push('lang=' + encodeURIComponent(o.lang)); }
+    if (o.apiKey) { q.push('key=' + encodeURIComponent(o.apiKey)); }
+    return q.length ? '?' + q.join('&') : '';
+  }
+
+  /** The style URL of a scheme or a custom style (`custom:<id>` → /v1/styles/custom/<id>). */
+  function styleUrl(style, o) {
+    o = o || {};
+    var base = String(o.baseUrl || DEFAULT_BASE).replace(/\/$/, '');
+    var s = styleName(style);
+    var path = s.indexOf('custom:') === 0 ? '/v1/styles/custom/' + encodeURIComponent(s.slice(7)) : '/v1/styles/' + s;
+    return base + path + query({ lang: o.lang || o.language || 'en', apiKey: o.apiKey });
+  }
+
+  /**
+   * sMap's raster tiles (contract §5) as an XYZ template, for tools without vector tiles:
+   * `${baseUrl}/v1/raster/<style>/{z}/{x}/{y}[@2x].png?lang=…[&key=…]`.
+   * @param o {lang, retina (512 px tiles), baseUrl, apiKey}
+   */
+  function rasterUrl(style, o) {
+    o = o || {};
+    var base = String(o.baseUrl || DEFAULT_BASE).replace(/\/$/, '');
+    return base + '/v1/raster/' + styleName(style) + '/{z}/{x}/{y}' + (o.retina ? '@2x' : '') + '.png' + query({ lang: o.lang || o.language, apiKey: o.apiKey });
+  }
+
+  /** The TileJSON of sMap's raster tiles of a style. */
+  function rasterTileJsonUrl(style, o) {
+    o = o || {};
+    var base = String(o.baseUrl || DEFAULT_BASE).replace(/\/$/, '');
+    return base + '/v1/raster/' + styleName(style) + '.json' + query({ lang: o.lang || o.language, apiKey: o.apiKey });
+  }
+
+  // Google and Bing tiles are never offered: their licences forbid it (M31).
+  var FORBIDDEN_HOSTS = /(^|\.)(google\.[a-z.]+|googleapis\.com|gstatic\.com|ggpht\.com|virtualearth\.net|bing\.com|bing\.net)$/i;
+  function refuseForbidden(urls) {
+    (urls || []).forEach(function (u) {
+      var m = /^[a-z][a-z0-9+.-]*:\/\/([^/?#:]+)/i.exec(String(u).replace(/^pmtiles:\/\//i, ''));
+      if (m && FORBIDDEN_HOSTS.test(m[1])) { throw new Error('sMap: Google and Bing tiles cannot be used (their licences do not allow it)'); }
+    });
+  }
+
+  /**
+   * A WMS GetMap tile URL template (Web Mercator, the engine fills {bbox-epsg-3857}).
+   * @param o {url, layers, styles, format, transparent, version ('1.3.0' | '1.1.1'), tileSize, params}
+   */
+  function wmsTileUrl(o) {
+    if (!o || !o.url || !o.layers) { throw new Error('sMap: a WMS layer needs url and layers'); }
+    var version = o.version || '1.3.0', size = o.tileSize || 256;
+    var p = {
+      SERVICE: 'WMS', REQUEST: 'GetMap', VERSION: version,
+      LAYERS: Array.isArray(o.layers) ? o.layers.join(',') : o.layers,
+      STYLES: Array.isArray(o.styles) ? o.styles.join(',') : (o.styles || ''),
+      FORMAT: o.format || 'image/png', TRANSPARENT: o.transparent === false ? 'FALSE' : 'TRUE',
+      WIDTH: String(size), HEIGHT: String(size),
+    };
+    p[version === '1.3.0' ? 'CRS' : 'SRS'] = 'EPSG:3857';
+    Object.keys(o.params || {}).forEach(function (k) { p[k] = String(o.params[k]); });
+    var url = String(o.url);
+    var sep = url.indexOf('?') < 0 ? '?' : (/[?&]$/.test(url) ? '' : '&');
+    return url + sep + Object.keys(p).map(function (k) { return k + '=' + encodeURIComponent(p[k]); }).join('&') + '&BBOX={bbox-epsg-3857}';
+  }
+
+  // ------------------------------------------------------------------ WMTS capabilities
+
+  var WEB_MERCATOR_SCALE0 = 559082264.0287178; // scale denominator of zoom 0 (256 px tiles, 0.28 mm pixels)
+  var MERCATOR_CRS = /(3857|900913|3785|102100|102113|GoogleMapsCompatible)/i;
+
+  /** Reads WMTS 1.0.0 capabilities: {layers: [{id, title, styles, formats, tileMatrixSets, resourceUrls, bounds}], tileMatrixSets: {id: {crs, matrices: [{id, zoom}]}}, getTile: kvp href}. */
+  function parseWmtsCapabilities(xml) {
+    var doc = parseXml(stripBom(String(xml)));
+    var caps = descendants(doc, 'Capabilities')[0] || doc;
+    var contents = elem(caps, 'Contents');
+    if (!contents) { throw new Error('sMap: not WMTS capabilities'); }
+    var sets = {};
+    elems(contents, 'TileMatrixSet').forEach(function (s) {
+      var id = trimmed(elem(s, 'Identifier'));
+      var crs = trimmed(elem(s, 'SupportedCRS'));
+      var matrices = elems(s, 'TileMatrix').map(function (m) {
+        var scale = parseFloat(trimmed(elem(m, 'ScaleDenominator')));
+        return { id: trimmed(elem(m, 'Identifier')), zoom: Math.round(Math.log(WEB_MERCATOR_SCALE0 / scale) / Math.LN2), tileWidth: parseInt(trimmed(elem(m, 'TileWidth')), 10) || 256 };
+      });
+      sets[id] = { id: id, crs: crs, wellKnown: trimmed(elem(s, 'WellKnownScaleSet')), matrices: matrices };
+    });
+    var layers = elems(contents, 'Layer').map(function (l) {
+      var bbox = elem(l, 'WGS84BoundingBox');
+      var lower = bbox ? trimmed(elem(bbox, 'LowerCorner')).split(/\s+/).map(Number) : null;
+      var upper = bbox ? trimmed(elem(bbox, 'UpperCorner')).split(/\s+/).map(Number) : null;
+      return {
+        id: trimmed(elem(l, 'Identifier')),
+        title: trimmed(elem(l, 'Title')),
+        styles: elems(l, 'Style').map(function (s) { return { id: trimmed(elem(s, 'Identifier')), isDefault: s.attrs.isDefault === 'true' }; }),
+        formats: elems(l, 'Format').map(trimmed),
+        tileMatrixSets: elems(l, 'TileMatrixSetLink').map(function (k) { return trimmed(elem(k, 'TileMatrixSet')); }),
+        resourceUrls: elems(l, 'ResourceURL').filter(function (r) { return (r.attrs.resourceType || 'tile') === 'tile'; }).map(function (r) { return { format: r.attrs.format, template: r.attrs.template }; }),
+        bounds: lower && upper && lower.length >= 2 && upper.length >= 2 ? [lower[0], lower[1], upper[0], upper[1]] : null,
+      };
+    });
+    var getTile = null;
+    descendants(caps, 'Operation').forEach(function (op) {
+      if (op.attrs.name !== 'GetTile') { return; }
+      descendants(op, 'Get').forEach(function (g) {
+        var enc = descendants(g, 'Value').map(trimmed);
+        if (!getTile && (!enc.length || enc.indexOf('KVP') >= 0)) { getTile = attr(g, 'href'); }
+      });
+    });
+    return { layers: layers, tileMatrixSets: sets, getTile: getTile };
+  }
+
+  // The zoom → matrix identifier rule of a set, as a template piece for {z}: identifiers equal to the zoom, or one
+  // prefix followed by the zoom (EPSG:3857:0, …). Anything else cannot be a {z} template.
+  function matrixTemplate(set) {
+    var ms = set.matrices.slice().sort(function (a, b) { return a.zoom - b.zoom; });
+    if (!ms.length) { throw new Error('sMap: WMTS matrix set ' + set.id + ' has no matrices'); }
+    var prefix = null;
+    for (var i = 0; i < ms.length; i++) {
+      var m = /^(.*?)(\d+)$/.exec(ms[i].id);
+      if (!m || Number(m[2]) !== ms[i].zoom) { throw new Error('sMap: WMTS matrix set ' + set.id + ': matrix ' + ms[i].id + ' is not named by its zoom'); }
+      if (prefix === null) { prefix = m[1]; } else if (prefix !== m[1]) { throw new Error('sMap: WMTS matrix set ' + set.id + ' mixes matrix names'); }
+    }
+    return { prefix: prefix, minzoom: ms[0].zoom, maxzoom: ms[ms.length - 1].zoom, tileSize: ms[0].tileWidth };
+  }
+
+  /**
+   * A raster source for one WMTS layer from its capabilities (KVP or REST; Web Mercator matrix sets only).
+   * @param caps  the text of GetCapabilities or parseWmtsCapabilities' answer
+   * @param o     {layer, tileMatrixSet, style, format, encoding ('rest' | 'kvp'), url (where the capabilities came
+   *              from, for a relative GetTile address)}
+   */
+  function wmtsSource(caps, o) {
+    o = o || {};
+    if (typeof caps === 'string') { caps = parseWmtsCapabilities(caps); }
+    var layer = o.layer ? caps.layers.filter(function (l) { return l.id === o.layer; })[0] : caps.layers[0];
+    if (!layer) { throw new Error('sMap: WMTS has no layer ' + (o.layer || '')); }
+    var setId = o.tileMatrixSet || layer.tileMatrixSets.filter(function (id) {
+      var s = caps.tileMatrixSets[id];
+      return s && (MERCATOR_CRS.test(s.crs) || MERCATOR_CRS.test(s.wellKnown) || MERCATOR_CRS.test(id));
+    })[0];
+    var set = caps.tileMatrixSets[setId];
+    if (!set) { throw new Error('sMap: WMTS layer ' + layer.id + ' has no Web Mercator matrix set'); }
+    var mt = matrixTemplate(set);
+    var style = o.style || (layer.styles.filter(function (s) { return s.isDefault; })[0] || layer.styles[0] || { id: 'default' }).id;
+    var format = o.format || layer.formats.filter(function (f) { return /png/i.test(f); })[0] || layer.formats[0] || 'image/png';
+    var rest = layer.resourceUrls.filter(function (r) { return !o.format || r.format === o.format; })[0] || layer.resourceUrls[0];
+    var tile;
+    if (rest && o.encoding !== 'kvp') {
+      tile = rest.template.replace(/\{TileMatrixSet\}/gi, set.id).replace(/\{TileMatrix\}/gi, mt.prefix + '{z}')
+        .replace(/\{TileRow\}/gi, '{y}').replace(/\{TileCol\}/gi, '{x}').replace(/\{Style\}/gi, style);
+    } else {
+      var href = caps.getTile || o.url;
+      if (!href) { throw new Error('sMap: WMTS capabilities name no GetTile address'); }
+      href = String(href);
+      var sep = href.indexOf('?') < 0 ? '?' : (/[?&]$/.test(href) ? '' : '&');
+      if (sep === '?' && o.url && href === o.url) { href = href.split('?')[0]; }
+      tile = href + sep + 'SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=' + encodeURIComponent(layer.id) + '&STYLE=' + encodeURIComponent(style) +
+        '&FORMAT=' + encodeURIComponent(format) + '&TILEMATRIXSET=' + encodeURIComponent(set.id) + '&TILEMATRIX=' + encodeURIComponent(mt.prefix) + '{z}&TILEROW={y}&TILECOL={x}';
+    }
+    var src = { type: 'raster', tiles: [tile], tileSize: mt.tileSize, minzoom: mt.minzoom, maxzoom: mt.maxzoom };
+    if (layer.bounds) { src.bounds = layer.bounds; }
+    return src;
+  }
+
+  // ------------------------------------------------------------------ PMTiles v3 (archives read by HTTP range)
+
+  function zxyToTileId(z, x, y) {
+    if (z > 26) { throw new Error('sMap: zoom above 26'); }
+    var acc = (Math.pow(4, z) - 1) / 3;
+    var n = Math.pow(2, z), rx, ry, d = 0, xy = [x, y];
+    for (var s = n / 2; s >= 1; s /= 2) {
+      rx = (xy[0] & s) > 0 ? 1 : 0;
+      ry = (xy[1] & s) > 0 ? 1 : 0;
+      d += s * s * ((3 * rx) ^ ry);
+      if (ry === 0) { if (rx === 1) { xy[0] = s - 1 - xy[0]; xy[1] = s - 1 - xy[1]; } var t = xy[0]; xy[0] = xy[1]; xy[1] = t; }
+    }
+    return acc + d;
+  }
+
+  function readVarint(b, at) {
+    var v = 0, mul = 1, byte;
+    do { byte = b[at.p++]; v += (byte & 0x7f) * mul; mul *= 128; } while (byte & 0x80);
+    return v;
+  }
+
+  function pmDirectory(bytes) {
+    var at = { p: 0 }, n = readVarint(bytes, at), entries = new Array(n), last = 0, i;
+    for (i = 0; i < n; i++) { last += readVarint(bytes, at); entries[i] = { tileId: last, offset: 0, length: 0, runLength: 1 }; }
+    for (i = 0; i < n; i++) { entries[i].runLength = readVarint(bytes, at); }
+    for (i = 0; i < n; i++) { entries[i].length = readVarint(bytes, at); }
+    for (i = 0; i < n; i++) {
+      var v = readVarint(bytes, at);
+      entries[i].offset = v === 0 && i > 0 ? entries[i - 1].offset + entries[i - 1].length : v - 1;
+    }
+    return entries;
+  }
+
+  function pmFind(entries, tileId) {
+    var lo = 0, hi = entries.length - 1;
+    while (lo <= hi) {
+      var mid = (lo + hi) >> 1, c = entries[mid].tileId - tileId;
+      if (c < 0) { lo = mid + 1; } else if (c > 0) { hi = mid - 1; } else { return entries[mid]; }
+    }
+    if (hi >= 0) {
+      var e = entries[hi];
+      if (e.runLength === 0) { return e; }
+      if (tileId - e.tileId < e.runLength) { return e; }
+    }
+    return null;
+  }
+
+  function u64(dv, p) { return dv.getUint32(p, true) + dv.getUint32(p + 4, true) * 4294967296; }
+
+  /** Reads the PMTiles v3 header (the first 127 bytes). */
+  function pmHeader(bytes) {
+    var dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (utf8(bytes.subarray(0, 7)) !== 'PMTiles') { throw new Error('sMap: not a PMTiles archive'); }
+    if (bytes[7] !== 3) { throw new Error('sMap: PMTiles version ' + bytes[7] + ' is not supported (3)'); }
+    return {
+      rootOffset: u64(dv, 8), rootLength: u64(dv, 16), metadataOffset: u64(dv, 24), metadataLength: u64(dv, 32),
+      leafOffset: u64(dv, 40), leafLength: u64(dv, 48), dataOffset: u64(dv, 56), dataLength: u64(dv, 64),
+      internalCompression: bytes[97], tileCompression: bytes[98], tileType: bytes[99], minZoom: bytes[100], maxZoom: bytes[101],
+      bounds: [dv.getInt32(102, true) / 1e7, dv.getInt32(106, true) / 1e7, dv.getInt32(110, true) / 1e7, dv.getInt32(114, true) / 1e7],
+      centerZoom: bytes[118], center: [dv.getInt32(119, true) / 1e7, dv.getInt32(123, true) / 1e7],
+    };
+  }
+
+  function pmDecompress(bytes, compression) {
+    if (compression === 0 || compression === 1) { return bytes; }
+    if (compression === 2) { return gunzip(bytes); }
+    throw new Error('sMap: PMTiles compression ' + compression + ' is not supported');
+  }
+
+  /**
+   * A PMTiles v3 archive read by HTTP range requests. `fetchRange(url, offset, length)` → Promise of bytes (default:
+   * fetch with a Range header).
+   */
+  function PMTilesArchive(url, fetchRange) {
+    this.url = url;
+    this._fetch = fetchRange || function (u, offset, length) {
+      return fetch(u, { headers: { Range: 'bytes=' + offset + '-' + (offset + length - 1) } }).then(function (res) {
+        if (!res.ok) { throw new Error('sMap: PMTiles HTTP ' + res.status); }
+        return res.arrayBuffer();
+      }).then(function (b) { return new Uint8Array(b); });
+    };
+    this._header = null;
+    this._dirs = {};
+  }
+  PMTilesArchive.prototype.header = function () {
+    var self = this;
+    if (!this._header) {
+      this._header = Promise.resolve(this._fetch(this.url, 0, 16384)).then(function (first) {
+        first = toBytes(first);
+        var h = pmHeader(first);
+        if (h.rootOffset + h.rootLength <= first.length) { self._dirs['root'] = pmDirectory(pmDecompress(first.subarray(h.rootOffset, h.rootOffset + h.rootLength), h.internalCompression)); }
+        return h;
+      });
+    }
+    return this._header;
+  };
+  PMTilesArchive.prototype._dir = function (key, offset, length, compression) {
+    var self = this;
+    if (this._dirs[key]) { return Promise.resolve(this._dirs[key]); }
+    return Promise.resolve(this._fetch(this.url, offset, length)).then(function (b) {
+      var d = pmDirectory(pmDecompress(toBytes(b), compression));
+      self._dirs[key] = d;
+      return d;
+    });
+  };
+  PMTilesArchive.prototype.metadata = function () {
+    var self = this;
+    return this.header().then(function (h) {
+      if (!h.metadataLength) { return {}; }
+      return Promise.resolve(self._fetch(self.url, h.metadataOffset, h.metadataLength)).then(function (b) {
+        try { return JSON.parse(utf8(pmDecompress(toBytes(b), h.internalCompression))); } catch (e) { return {}; }
+      });
+    });
+  };
+  /** The tile's bytes (decompressed), or null when the archive has none. */
+  PMTilesArchive.prototype.tile = function (z, x, y) {
+    var self = this, id = zxyToTileId(z, x, y);
+    return this.header().then(function (h) {
+      if (z < h.minZoom || z > h.maxZoom) { return null; }
+      var walk = function (key, offset, length, depth) {
+        return self._dir(key, offset, length, h.internalCompression).then(function (entries) {
+          var e = pmFind(entries, id);
+          if (!e) { return null; }
+          if (e.runLength > 0) {
+            return Promise.resolve(self._fetch(self.url, h.dataOffset + e.offset, e.length)).then(function (b) { return pmDecompress(toBytes(b), h.tileCompression); });
+          }
+          if (depth > 3) { return null; }
+          return walk('leaf:' + e.offset, h.leafOffset + e.offset, e.length, depth + 1);
+        });
+      };
+      return walk('root', h.rootOffset, h.rootLength, 0);
+    });
+  };
+  /** TileJSON for the engine: tiles through the pmtiles:// protocol. */
+  PMTilesArchive.prototype.tileJSON = function () {
+    var self = this;
+    return Promise.all([this.header(), this.metadata()]).then(function (r) {
+      var h = r[0], meta = r[1] || {};
+      var tj = { tilejson: '3.0.0', tiles: ['pmtiles://' + self.url + '/{z}/{x}/{y}'], minzoom: h.minZoom, maxzoom: h.maxZoom, bounds: h.bounds };
+      if (meta.vector_layers) { tj.vector_layers = meta.vector_layers; }
+      if (meta.attribution) { tj.attribution = meta.attribution; }
+      tj.tileType = h.tileType;
+      return tj;
+    });
+  };
+
+  var archives = {};
+  /**
+   * The `pmtiles://` protocol for the engine (engine.addProtocol('pmtiles', pmtilesProtocol)): `pmtiles://<url>`
+   * answers TileJSON, `pmtiles://<url>/{z}/{x}/{y}` the tile.
+   */
+  function pmtilesProtocol(params) {
+    var rest = String(params.url).replace(/^pmtiles:\/\//, '');
+    var m = /^(.*)\/(\d+)\/(\d+)\/(\d+)$/.exec(rest);
+    var url = m ? m[1] : rest;
+    var a = archives[url] || (archives[url] = new PMTilesArchive(url));
+    if (!m) { return a.tileJSON().then(function (tj) { return { data: tj }; }); }
+    return a.tile(Number(m[2]), Number(m[3]), Number(m[4])).then(function (b) {
+      return { data: b ? b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength) : new ArrayBuffer(0) };
+    });
+  }
+
+  // ------------------------------------------------------------------ deck.gl (optional, M36)
+
+  var deckModule = null;
+  /** Registers deck.gl's map overlay: useDeck(await import('@deck.gl/mapbox')) or useDeck({ MapboxOverlay }). */
+  function useDeck(mod) { deckModule = mod && (mod.MapboxOverlay ? mod : (mod['default'] && mod['default'].MapboxOverlay ? mod['default'] : null)); if (!deckModule) { throw new Error('sMap: useDeck needs the @deck.gl/mapbox module (MapboxOverlay)'); } return deckModule; }
+  function deck() {
+    if (deckModule) { return deckModule; }
+    var g = typeof globalThis !== 'undefined' ? globalThis : (typeof window !== 'undefined' ? window : {});
+    if (g.deck && g.deck.MapboxOverlay) { return g.deck; }
+    return null;
+  }
+
+  // ------------------------------------------------------------------ layer description (M32, shared/LAYER-JSON.md)
+
+  function jsonSafe(v) {
+    if (v === null || typeof v === 'number' || typeof v === 'string' || typeof v === 'boolean') { return v; }
+    if (typeof v === 'function' || v === undefined) { return undefined; }
+    if (Array.isArray(v)) { return v.map(function (x) { var y = jsonSafe(x); return y === undefined ? null : y; }); }
+    if (typeof v === 'object') {
+      var o = {};
+      Object.keys(v).forEach(function (k) { var y = jsonSafe(v[k]); if (y !== undefined) { o[k] = y; } });
+      return o;
+    }
+    return undefined;
+  }
+
+  /** Checks a layer description's outer shape (LAYER-JSON.md); throws with a message. */
+  function checkLayerJson(json) {
+    if (typeof json === 'string') { json = JSON.parse(json); }
+    if (!json || json.type !== 'smap.layers') { throw new Error('sMap: not an sMap layer description (type smap.layers)'); }
+    if (typeof json.version !== 'number' || Math.floor(json.version) > 1) { throw new Error('sMap: layer description version ' + json.version + ' is newer than this SDK reads (1)'); }
+    if (!Array.isArray(json.layers)) { throw new Error('sMap: a layer description needs layers'); }
+    json.layers.forEach(function (l, i) {
+      if (!l || typeof l.id !== 'string' || !l.id) { throw new Error('sMap: layer ' + i + ' has no id'); }
+      if (['points', 'lines', 'polygons', 'style'].indexOf(l.kind) < 0) { throw new Error('sMap: layer ' + l.id + ' has an unknown kind ' + l.kind); }
+      if (l.slot !== undefined && SLOTS.indexOf(l.slot) < 0) { throw new Error('sMap: layer ' + l.id + ' has an unknown slot ' + l.slot); }
+    });
+    return json;
+  }
+
+  return {
+    DEFAULT_BASE: DEFAULT_BASE,
+    SLOTS: SLOTS,
+    basemapClasses: basemapClasses,
+    basemapLayerIndex: basemapLayerIndex,
+    applyBasemapOverrides: applyBasemapOverrides,
+    overrideOrder: overrideOrder,
+    effectiveOverrides: effectiveOverrides,
+    scaledWidth: scaledWidth,
+    slotAnchors: slotAnchors,
+    formats: {
+      list: FORMATS.slice(),
+      read: read,
+      readFile: readFile,
+      write: write,
+      toKML: writeKml,
+      sniff: sniff,
+      formatOfName: formatOfName,
+      decodePolyline: decodePolyline,
+      encodePolyline: encodePolyline,
+    },
+    convert: convert,
+    styleUrl: styleUrl,
+    rasterUrl: rasterUrl,
+    rasterTileJsonUrl: rasterTileJsonUrl,
+    wmsTileUrl: wmsTileUrl,
+    refuseForbidden: refuseForbidden,
+    parseWmtsCapabilities: parseWmtsCapabilities,
+    wmtsSource: wmtsSource,
+    PMTilesArchive: PMTilesArchive,
+    pmtilesProtocol: pmtilesProtocol,
+    zxyToTileId: zxyToTileId,
+    inflateRaw: inflateRaw,
+    gunzip: gunzip,
+    unzip: unzip,
+    parseXml: parseXml,
+    useDeck: useDeck,
+    deck: deck,
+    jsonSafe: jsonSafe,
+    checkLayerJson: checkLayerJson,
+  };
+});
+
+  return module.exports;
+}
+function smapCreateSdk(engine, interop) {
   var module = { exports: {} };
   var exports = module.exports;
   var define;
   var require = function (name) { throw new Error('sMap: unexpected require of ' + name); };
-  var self = { maplibregl: engine };
+  var self = { maplibregl: engine, smapInterop: interop };
 /*!
  * sMap Web SDK — maps from Superroute's sMap service.
  *
@@ -26863,14 +28342,15 @@ function smapCreateSdk(engine) {
  */
 (function (root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory(root.maplibregl !== undefined ? root.maplibregl : require('maplibre-gl'));
+    module.exports = factory(root.maplibregl !== undefined ? root.maplibregl : require('maplibre-gl'),
+      root.smapInterop !== undefined ? root.smapInterop : require('./smap-interop.js'));
   } else {
-    root.sMap = factory(root.maplibregl);
+    root.sMap = factory(root.maplibregl, root.smapInterop);
   }
-})(typeof self !== 'undefined' ? self : this, function (engine) {
+})(typeof self !== 'undefined' ? self : this, function (engine, interop) {
   'use strict';
 
-  var VERSION = '1.0.5';
+  var VERSION = '1.1.0';
   var FLAVORS = ['light', 'white', 'grayscale', 'dark', 'black'];
   var BASEMAP_SOURCE = 'basemap';
   var BUILDINGS_LAYER = 'smap-buildings-3d';
@@ -26878,6 +28358,8 @@ function smapCreateSdk(engine) {
   // The public sMap address, unless the page names another (`baseUrl`). Never derived from where this file was loaded:
   // the SDK is published apart from the map service.
   var DEFAULT_BASE = 'https://tile.srsr.ca';
+  var CUSTOM_PREFIX = 'custom:';
+  var SLOTS = ['bottom', 'roads', 'labels', 'top'];
 
   function tokenExpiry(token) {
     try {
@@ -27025,7 +28507,7 @@ function smapCreateSdk(engine) {
   // from the position (right of the round part, as the page's badge sits on the turned pin's corner).
   function markerGeometry(shape, size) {
     var k = size / 32;
-    if (shape === 'circle') {
+    if (shape === 'circle' || shape === 'vehicle') {
       return { k: k, tipToHead: 0, badge: [size * 0.36, -size * 0.36] };
     }
     var half = size * SQRT1_2; // the centre of the round part, above the tip
@@ -27051,16 +28533,18 @@ function smapCreateSdk(engine) {
 
   // Each draw function gets a 2D context already scaled to the pixel ratio and returns nothing; sizes are in pixels.
   var IMAGE_KINDS = {
-    // pin|shape|fill|border|borderWidth|size
+    // pin|shape|fill|border|borderWidth|size  (shape pin, circle, or vehicle: the route map's live position, a white
+    // circle with a truck in the border colour)
     pin: function (args) {
       var shape = args[0], fill = args[1], border = args[2], bw = Number(args[3]), size = Number(args[4]);
       var g = markerGeometry(shape, size);
-      var reach = shape === 'circle' ? size / 2 : g.tipToHead; // farthest the shape goes from its centre
+      var reach = shape === 'pin' ? g.tipToHead : size / 2; // farthest the shape goes from its centre
       var w = Math.ceil(2 * reach + 2 * PIN_PAD), h = w;
       return {
         width: w, height: h,
         draw: function (ctx, ratio) {
           var c = w / 2;
+          if (shape === 'vehicle') { drawVehicle(ctx, ratio, c, size, border); return; }
           ctx.save();
           ctx.translate(c, c);
           var s = size / 2;
@@ -27091,6 +28575,31 @@ function smapCreateSdk(engine) {
         },
       };
     },
+    // pinnum|shape|fill|border|borderWidth|size|textColor|text: a pin with its number drawn in, so a pin above covers a
+    // pin below completely (used close up, where few pins are in view; further out the number is its own layer).
+    pinnum: function (args, measure) {
+      var pin = IMAGE_KINDS.pin(args.slice(0, 5));
+      var size = Number(args[4]), color = args[5], text = args.slice(6).join('|');
+      var px = 14 * size / 32, font = 'bold ' + px + 'px monospace';
+      return {
+        width: pin.width, height: pin.height,
+        draw: function (ctx, ratio) {
+          pin.draw(ctx, ratio);
+          if (text === '') { return; }
+          ctx.save();
+          ctx.font = font;
+          ctx.textAlign = 'center';
+          ctx.textBaseline = 'middle';
+          ctx.shadowColor = 'rgba(0,0,0,0.5)';
+          ctx.shadowOffsetX = ratio;
+          ctx.shadowOffsetY = ratio;
+          ctx.shadowBlur = 2 * ratio;
+          ctx.fillStyle = color;
+          ctx.fillText(text, pin.width / 2, pin.height / 2 + 0.5);
+          ctx.restore();
+        },
+      };
+    },
     // num|color|size|text   (bold, with the route map's text shadow)
     num: function (args, measure) {
       var color = args[0], size = Number(args[1]), text = args.slice(2).join('|');
@@ -27164,6 +28673,9 @@ function smapCreateSdk(engine) {
     },
   };
 
+  // A number from a feature property, `fallback` when it has none.
+  function numberProp(name, fallback) { return ['to-number', ['coalesce', ['get', name], fallback], fallback]; }
+
   function drawnImageId(kind, parts) { return ['concat', IMAGE_PREFIX + kind].concat(parts.reduce(function (a, p) { return a.concat(['|', p]); }, [])); }
 
   var NODE_TTL = 3600 * 1000;
@@ -27259,12 +28771,26 @@ function smapCreateSdk(engine) {
     this._token = options.token || null;
     this._getToken = options.getToken || null;
     this._apiKey = options.apiKey || null;
-    this._flavor = typeof options.style === 'string' && FLAVORS.indexOf(options.style) >= 0 ? options.style : 'light';
-    this._customStyle = options.style && FLAVORS.indexOf(options.style) < 0 ? options.style : null;
+    this._flavor = 'light';
+    this._customStyle = null;
+    this._serverStyle = null;
+    this._takeStyle(options.style);
     this._language = options.language || (typeof navigator !== 'undefined' && navigator.language) || 'en';
     this._projection = options.projection || 'mercator';
     this._layers = {};
     this._order = [];
+    // Style Spec sources added with addSource (or by the external-layer helpers), re-added after every style change.
+    this._sources = {};
+    this._sourceOrder = [];
+    // Basemap class overrides (setBasemap), the basemap's own layer ids and their values before any override.
+    this._basemapOverrides = {};
+    this._basemapIds = [];
+    this._basemapOriginal = {};
+    // setPaint / setLayout / setFilter on basemap layers, applied again after a style change.
+    this._basemapEdits = {};
+    this._deckLayers = [];
+    this._deckOverlay = null;
+    this._seq = 0;
     this._buildings = false;
     this._handlers = {};
     this._refreshTimer = null;
@@ -27327,8 +28853,16 @@ function smapCreateSdk(engine) {
     if (this._token && this._getToken) { this._scheduleRefresh(); }
   }
 
+  // A scheme, `custom:<id>` (a saved custom style served by sMap), or a style URL / object of your own.
+  SMap.prototype._takeStyle = function (style) {
+    if (typeof style === 'string' && FLAVORS.indexOf(style) >= 0) { this._flavor = style; this._customStyle = null; this._serverStyle = null; }
+    else if (typeof style === 'string' && style.indexOf(CUSTOM_PREFIX) === 0) { this._customStyle = null; this._serverStyle = style; }
+    else if (style) { this._customStyle = style; this._serverStyle = null; }
+  };
+
   SMap.prototype._styleUrl = function () {
     if (this._customStyle) { return this._customStyle; }
+    if (this._serverStyle) { return interop.styleUrl(this._serverStyle, { baseUrl: this._base, lang: this._language, apiKey: this._apiKey }); }
     var url = this._base + '/v1/styles/' + this._flavor + '?lang=' + encodeURIComponent(this._language);
     return this._apiKey ? url + '&key=' + encodeURIComponent(this._apiKey) : url;
   };
@@ -27354,7 +28888,7 @@ function smapCreateSdk(engine) {
 
   /** Switches the colour scheme ('light', 'white', 'grayscale', 'dark', 'black'); your layers are kept. */
   SMap.prototype.setStyle = function (style) {
-    if (FLAVORS.indexOf(style) >= 0) { this._flavor = style; this._customStyle = null; } else { this._customStyle = style; }
+    this._takeStyle(style);
     this._styleReady = false;
     this.engine.setStyle(this._styleUrl());
     this._styleClass();
@@ -27366,10 +28900,31 @@ function smapCreateSdk(engine) {
     var c = this.engine && this.engine.getContainer && this.engine.getContainer();
     if (!c || !c.classList) { return; }
     for (var i = 0; i < FLAVORS.length; i++) { c.classList.remove('smap-style-' + FLAVORS[i]); }
-    if (!this._customStyle) { c.classList.add('smap-style-' + this._flavor); }
+    if (!this._customStyle && !this._serverStyle) { c.classList.add('smap-style-' + this._flavor); }
   };
 
   // Draws an image the SDK named (IMAGE_PREFIX + kind|args) and adds it to the map; other names are left alone.
+  // The live-position marker of the route map: a white circle (85%) with a truck in the driver colour.
+  function drawVehicle(ctx, ratio, c, size, color) {
+    var r = size / 2, k = size / 24;
+    ctx.save();
+    ctx.translate(c, c);
+    ctx.shadowColor = 'rgba(0,0,0,0.5)';
+    ctx.shadowBlur = 2 * ratio;
+    ctx.beginPath(); ctx.arc(0, 0, r, 0, Math.PI * 2);
+    ctx.fillStyle = 'rgba(255,255,255,0.85)'; ctx.fill();
+    ctx.shadowColor = 'transparent';
+    ctx.scale(k, k);
+    ctx.fillStyle = color;
+    // cargo box, cab and two wheels, about 14 x 10 px on a 24 px marker
+    ctx.fillRect(-7, -5, 8.5, 7);
+    roundedPath(ctx, 2.2, -2.6, 4.8, 4.6, [[1.4, 1.4], [0.6, 0.6], [0, 0], [0, 0]]); ctx.fill();
+    ctx.beginPath(); ctx.arc(-4.2, 3.4, 1.9, 0, Math.PI * 2); ctx.arc(4.1, 3.4, 1.9, 0, Math.PI * 2); ctx.fill();
+    ctx.fillStyle = 'rgba(255,255,255,0.85)';
+    ctx.beginPath(); ctx.arc(-4.2, 3.4, 0.7, 0, Math.PI * 2); ctx.arc(4.1, 3.4, 0.7, 0, Math.PI * 2); ctx.fill();
+    ctx.restore();
+  }
+
   SMap.prototype._drawImage = function (id) {
     if (typeof id !== 'string' || id.indexOf(IMAGE_PREFIX) !== 0) { return; }
     var m = this.engine;
@@ -27545,12 +29100,12 @@ function smapCreateSdk(engine) {
     // Points open at their own position; lines and areas where they were clicked.
     var at = hit.kind === 'points' && f.geometry && f.geometry.type === 'Point' ? f.geometry.coordinates : lngLat;
     var content;
-    try { content = hit.o.popup(f.properties || {}, f); } catch (error) { this._reportError(error); return; }
+    try { content = (hit.popupFn || hit.o.popup)(f.properties || {}, f); } catch (error) { this._reportError(error); return; }
     var popupOptions = Object.assign({}, hit.o.popupOptions || {});
     if (hit.o.marker && popupOptions.offset === undefined && this._popupDefaults.offset === undefined) {
       // Just above the pin as it is drawn now (its scale may follow the zoom).
       var mk = hit.o.marker, size = mk.size || 32, k = scaleAt(mk.scale, m.getZoom ? m.getZoom() : 0);
-      popupOptions.offset = mk.shape === 'circle' ? Math.round((size / 2) * k + 4) : Math.round((markerGeometry('pin', size).tipToHead + size / 2) * k + 2);
+      popupOptions.offset = mk.shape === 'circle' || mk.shape === 'vehicle' ? Math.round((size / 2) * k + 4) : Math.round((markerGeometry('pin', size).tipToHead + size / 2) * k + 2);
     }
     // Above the pin, always (as on Superroute's route map); the map pans to make room instead of flipping it below.
     if (hit.o.marker && popupOptions.anchor === undefined && this._popupDefaults.anchor === undefined) { popupOptions.anchor = 'bottom'; }
@@ -27595,6 +29150,7 @@ function smapCreateSdk(engine) {
 
   SMap.prototype.setLanguage = function (language) {
     this._language = language;
+    // A scheme or a custom style of sMap is served per language; a style of your own keeps its labels.
     if (!this._customStyle) { this._styleReady = false; this.engine.setStyle(this._styleUrl()); }
     return this;
   };
@@ -27648,7 +29204,15 @@ function smapCreateSdk(engine) {
     if (!this._buildings || !m.getSource(BASEMAP_SOURCE)) { return; }
     var o = this._buildingOptions || {};
     var dark = this._flavor === 'dark' || this._flavor === 'black';
+    // Under the lowest of your layers, wherever its slot put it.
     var firstUserLayer = this._order.length ? this._firstEngineLayer(this._order[0]) : undefined;
+    var st = m.getStyle && m.getStyle();
+    if (st && Array.isArray(st.layers)) {
+      var mine = {}, self = this;
+      this._order.forEach(function (id) { self._layers[id].engineLayers.forEach(function (l) { mine[l] = true; }); });
+      firstUserLayer = undefined;
+      for (var i = 0; i < st.layers.length; i++) { if (mine[st.layers[i].id]) { firstUserLayer = st.layers[i].id; break; } }
+    }
     m.addLayer({
       id: BUILDINGS_LAYER,
       type: 'fill-extrusion',
@@ -27717,12 +29281,24 @@ function smapCreateSdk(engine) {
     return this;
   };
 
+  /**
+   * Removes a layer: one of the SDK's own (addPoints, addLines, addPolygons; addData's whole group), a style layer
+   * (addStyleLayer and the external-layer helpers, with the source a helper made for it), or a source of addSource.
+   */
   SMap.prototype.removeLayer = function (id) {
-    var def = this._layers[id];
-    if (!def) { return this; }
-    this._drop(id, def);
-    delete this._layers[id];
-    this._order = this._order.filter(function (x) { return x !== id; });
+    var self = this;
+    var ids = this._order.filter(function (x) { return x === id || self._layers[x].group === id; });
+    if (!ids.length) {
+      if (this._sources[id]) { this.removeSource(id); }
+      return this;
+    }
+    ids.forEach(function (x) {
+      var def = self._layers[x];
+      self._drop(x, def);
+      delete self._layers[x];
+      self._order = self._order.filter(function (y) { return y !== x; });
+      if (def.ownsSource && self._sources[def.ownsSource] && !self._sourceInUse(def.ownsSource)) { self.removeSource(def.ownsSource); }
+    });
     return this;
   };
 
@@ -27746,8 +29322,549 @@ function smapCreateSdk(engine) {
   SMap.prototype.flyTo = function (o) { this.engine.flyTo(o); return this; };
   SMap.prototype.remove = function () { clearTimeout(this._refreshTimer); if (this.engine) { this.engine.remove(); } };
 
+  // ------------------------------------------------------------------ Style Specification sources and layers (M24)
+
+  function clone(v) { return v === undefined ? undefined : JSON.parse(JSON.stringify(v)); }
+
+  function sourceUrls(source) {
+    var urls = [];
+    if (source && source.url) { urls.push(source.url); }
+    if (source && Array.isArray(source.tiles)) { urls = urls.concat(source.tiles); }
+    return urls;
+  }
+
+  // The pmtiles:// protocol, registered on the engine the first time a source needs it.
+  var pmtilesRegistered = false;
+  function needsPmtiles(source) { return sourceUrls(source).some(function (u) { return /^pmtiles:\/\//i.test(String(u)); }); }
+  function registerPmtiles() {
+    if (pmtilesRegistered || !engine || !engine.addProtocol) { return; }
+    engine.addProtocol('pmtiles', interop.pmtilesProtocol);
+    pmtilesRegistered = true;
+  }
+
+  SMap.prototype._engineSource = function (id) {
+    var source = this._sources[id];
+    if (needsPmtiles(source)) { registerPmtiles(); }
+    this.engine.addSource(id, source);
+  };
+
+  SMap.prototype._sourceInUse = function (id) {
+    var self = this;
+    return this._order.some(function (x) { var d = self._layers[x]; return d.kind === 'style' && d.layer.source === id; });
+  };
+
+  /**
+   * Adds a source of the Style Specification v8 (geojson, vector, raster, raster-dem, image, video), passed to the
+   * engine as it is and kept across style and language changes. Its `attribution` is shown beside the map's credit.
+   * `pmtiles://<url>` reads a PMTiles archive. Google and Bing tiles are refused.
+   */
+  SMap.prototype.addSource = function (id, source) {
+    if (!id || !source || typeof source !== 'object' || !source.type) { throw new Error('sMap: addSource needs an id and a source with a type'); }
+    if (id === BASEMAP_SOURCE) { throw new Error('sMap: the source id "basemap" belongs to the map'); }
+    interop.refuseForbidden(sourceUrls(source));
+    if (this._sources[id]) { this.removeSource(id); }
+    this._sources[id] = source;
+    this._sourceOrder.push(id);
+    if (this.engine && this._styleReady) { this._engineSource(id); }
+    return this;
+  };
+
+  /** Removes a source of addSource and the style layers that read it. */
+  SMap.prototype.removeSource = function (id) {
+    var self = this;
+    if (!this._sources[id]) { return this; }
+    this._order.filter(function (x) { var d = self._layers[x]; return d.kind === 'style' && d.layer.source === id; })
+      .forEach(function (x) { var d = self._layers[x]; d.ownsSource = null; self.removeLayer(x); });
+    delete this._sources[id];
+    this._sourceOrder = this._sourceOrder.filter(function (x) { return x !== id; });
+    var m = this.engine;
+    if (m && m.getSource && m.getSource(id) && m.removeSource) { m.removeSource(id); }
+    return this;
+  };
+
+  /** The sources added with addSource: {id: source}. */
+  SMap.prototype.sources = function () {
+    var out = {}, self = this;
+    this._sourceOrder.forEach(function (id) { out[id] = clone(self._sources[id]); });
+    return out;
+  };
+
+  /**
+   * Adds a layer of the Style Specification v8, passed to the engine as it is: a layer copied from a style editor or
+   * another map page works unchanged. Its `source` is a source of addSource, an inline source, or `basemap`.
+   * @param {Object} layer
+   * @param {Object} [o]  {slot: 'bottom' | 'roads' | 'labels' | 'top', before: layer id, zIndex}; without either the
+   *                      layer draws on top, in the order added
+   */
+  SMap.prototype.addStyleLayer = function (layer, o) {
+    if (!layer || !layer.id || !layer.type) { throw new Error('sMap: addStyleLayer needs a layer with an id and a type'); }
+    o = o || {};
+    if (typeof layer.source === 'object' && layer.source) { interop.refuseForbidden(sourceUrls(layer.source)); }
+    var def = { kind: 'style', layer: clone(layer), o: { slot: o.slot, before: o.before, zIndex: o.zIndex } };
+    if (layer.layout && layer.layout.visibility === 'none') { def.hidden = true; }
+    this._define(layer.id, def);
+    return this;
+  };
+
+  // The style layer of an id, the basemap's (and any engine layer's) when it is not one of yours.
+  SMap.prototype._edit = function (layerId, apply) {
+    var def = this._layers[layerId];
+    if (def && def.kind !== 'style') { throw new Error('sMap: ' + layerId + ' is a layer of addPoints / addLines / addPolygons; set its look with its options'); }
+    if (def) { apply(def.layer); } else {
+      var e = this._basemapEdits[layerId] = this._basemapEdits[layerId] || { paint: {}, layout: {} };
+      apply(e);
+    }
+  };
+
+  function setKey(obj, group, name, value) {
+    obj[group] = obj[group] || {};
+    if (value === undefined || value === null) { delete obj[group][name]; } else { obj[group][name] = value; }
+  }
+
+  /** Sets a paint property of a style layer (yours or the basemap's); kept across style changes. */
+  SMap.prototype.setPaint = function (layerId, name, value) {
+    this._edit(layerId, function (l) { setKey(l, 'paint', name, value); });
+    var m = this.engine;
+    if (m && this._styleReady && m.getLayer(layerId)) { m.setPaintProperty(layerId, name, value === null ? undefined : value); }
+    return this;
+  };
+
+  /** Sets a layout property of a style layer (yours or the basemap's); kept across style changes. */
+  SMap.prototype.setLayout = function (layerId, name, value) {
+    this._edit(layerId, function (l) { setKey(l, 'layout', name, value); });
+    var def = this._layers[layerId];
+    if (def && name === 'visibility') { def.hidden = value === 'none'; }
+    var m = this.engine;
+    if (m && this._styleReady && m.getLayer(layerId)) { m.setLayoutProperty(layerId, name, value === null ? undefined : value); }
+    return this;
+  };
+
+  /** Sets (or with null clears) the filter of a style layer; kept across style changes. */
+  SMap.prototype.setFilter = function (layerId, filter) {
+    this._edit(layerId, function (l) { if (filter === undefined || filter === null) { delete l.filter; } else { l.filter = filter; } });
+    var m = this.engine;
+    if (m && this._styleReady && m.getLayer(layerId)) { m.setFilter(layerId, filter === undefined ? null : filter); }
+    return this;
+  };
+
+  SMap.prototype._applyEdits = function (id, e) {
+    var m = this.engine;
+    if (!m.getLayer(id)) { return; }
+    Object.keys(e.paint || {}).forEach(function (k) { m.setPaintProperty(id, k, e.paint[k]); });
+    Object.keys(e.layout || {}).forEach(function (k) { m.setLayoutProperty(id, k, e.layout[k]); });
+    if (e.filter !== undefined) { m.setFilter(id, e.filter); }
+  };
+
+  /** A style layer as a Style Specification object (a copy): yours, or the basemap's; null when there is none. */
+  SMap.prototype.getStyleLayer = function (layerId) {
+    var def = this._layers[layerId];
+    if (def && def.kind === 'style') { return clone(def.layer); }
+    if (def) { return null; }
+    var st = this.engine && this.engine.getStyle && this.engine.getStyle();
+    var found = st && st.layers ? st.layers.filter(function (l) { return l.id === layerId; })[0] : null;
+    return found ? clone(found) : null;
+  };
+
+  // ------------------------------------------------------------------ basemap options (M26)
+
+  // The basemap's layers as the style came (before any override): ids in order and, for layers of the class
+  // table, their paint and layout.
+  SMap.prototype._snapshotBasemap = function () {
+    var m = this.engine;
+    var st = m.getStyle && m.getStyle();
+    var layers = st && Array.isArray(st.layers) ? st.layers : [];
+    var index = interop.basemapLayerIndex();
+    var mine = {}, self = this;
+    this._order.forEach(function (id) { (self._layers[id].engineLayers || []).forEach(function (l) { mine[l] = true; }); });
+    this._basemapIds = layers.map(function (l) { return l.id; }).filter(function (id) { return !mine[id] && id !== BUILDINGS_LAYER; });
+    this._basemapOriginal = {};
+    this._basemapApplied = {};
+    layers.forEach(function (l) {
+      if (index[l.id]) { self._basemapOriginal[l.id] = { id: l.id, paint: clone(l.paint) || {}, layout: clone(l.layout) || {} }; }
+    });
+  };
+
+  // Sets on the engine what the overrides change (and back what they no longer change).
+  SMap.prototype._applyBasemap = function () {
+    var m = this.engine, self = this;
+    var ids = Object.keys(this._basemapOriginal);
+    if (!ids.length) { return; }
+    var styled = interop.applyBasemapOverrides({ layers: ids.map(function (id) { return self._basemapOriginal[id]; }) }, this._basemapOverrides);
+    styled.layers.forEach(function (l) {
+      var before = self._basemapApplied[l.id] || self._basemapOriginal[l.id];
+      var same = function (a, b) { return JSON.stringify(a) === JSON.stringify(b); };
+      var keys = function (a, b) { var k = {}; Object.keys(a || {}).concat(Object.keys(b || {})).forEach(function (x) { k[x] = true; }); return Object.keys(k); };
+      if (!m.getLayer(l.id)) { return; }
+      keys(before.paint, l.paint).forEach(function (k) { if (!same(before.paint[k], l.paint[k])) { m.setPaintProperty(l.id, k, l.paint[k]); } });
+      keys(before.layout, l.layout).forEach(function (k) { if (!same(before.layout[k], l.layout[k])) { m.setLayoutProperty(l.id, k, l.layout[k]); } });
+      self._basemapApplied[l.id] = l;
+    });
+  };
+
+  /**
+   * Shows, hides and recolours the basemap by class (`water`, `land`, `parks`, `roads` and `roads.highway` … ,
+   * `labels` and `labels.places` …, `pois`, …): {class: {visible, color, casing, halo, opacity, width}}. Replaces the
+   * overrides set before ({} clears them); kept across style and language changes. An unknown class or field throws.
+   */
+  SMap.prototype.setBasemap = function (overrides) {
+    interop.overrideOrder(overrides || {});
+    this._basemapOverrides = clone(overrides || {});
+    if (this.engine && this._styleReady) { this._applyBasemap(); }
+    return this;
+  };
+
+  /** The basemap overrides in force (a copy). */
+  SMap.prototype.basemap = function () { return clone(this._basemapOverrides); };
+
+  // ------------------------------------------------------------------ files (M28–M30)
+
+  function isFileLike(v) { return !!v && typeof v === 'object' && typeof v.arrayBuffer === 'function' && !(v instanceof Uint8Array); }
+
+  // A popup from simplestyle properties (title or name, description), HTML-escaped; nothing when a feature has neither.
+  function simplestylePopup(p) {
+    var title = p.title !== undefined && p.title !== null && p.title !== '' ? p.title : p.name;
+    var desc = p.description !== undefined && p.description !== null && p.description !== '' ? p.description : p.desc;
+    if ((title === undefined || title === null || title === '') && (desc === undefined || desc === null || desc === '')) { return null; }
+    return '<div class="smap-simplestyle">' + (title !== undefined && title !== null && title !== '' ? '<b>' + escapeHtml(title) + '</b>' : '') +
+      (desc !== undefined && desc !== null && desc !== '' ? (title ? '<br>' : '') + escapeHtml(desc) : '') + '</div>';
+  }
+
+  var FILE_OPTIONS = ['format', 'lat', 'lng', 'name'];
+
+  /**
+   * Reads a file (KML, KMZ, GPX, encoded polyline, WKT, WKB, CSV, TopoJSON, GeoJSON) and draws it: its points as the
+   * layer `<id>`, its lines as `<id>:lines`, its areas as `<id>:areas` (only those it has), with simplestyle
+   * properties drawn when no colour is given, and a popup of each feature's title / name and description unless
+   * `popup` is given. `removeLayer(id)` removes all three, `toGeoJSON(id)` gives them back together.
+   * @param input  text, bytes, a parsed object, or a File / Blob (format from its name when not given)
+   * @param o      {format, lat, lng, ...the options of addPoints / addLines / addPolygons}
+   * @returns Promise of the map, once drawn (rejected when the file cannot be read)
+   */
+  SMap.prototype.addData = function (id, input, o) {
+    var self = this;
+    o = o || {};
+    var read = isFileLike(input) ? interop.formats.readFile(input, o) : new Promise(function (resolve) { resolve(interop.formats.read(input, o)); });
+    return read.then(function (data) { self._addFeatures(id, data, o); return self; });
+  };
+
+  SMap.prototype._addFeatures = function (id, data, o) {
+    var points = [], lines = [], areas = [];
+    var place = function (f, g) {
+      if (!g) { return; }
+      if (g.type === 'GeometryCollection') { (g.geometries || []).forEach(function (x) { place(f, x); }); return; }
+      var part = { type: 'Feature', properties: f.properties || {}, geometry: g };
+      if (f.id !== undefined) { part.id = f.id; }
+      if (g.type === 'Point' || g.type === 'MultiPoint') { points.push(part); }
+      else if (g.type === 'LineString' || g.type === 'MultiLineString') { lines.push(part); }
+      else if (g.type === 'Polygon' || g.type === 'MultiPolygon') { areas.push(part); }
+    };
+    (data.features || []).forEach(function (f) { place(f, f.geometry); });
+    this.removeLayer(id);
+    var opts = {};
+    Object.keys(o).forEach(function (k) { if (FILE_OPTIONS.indexOf(k) < 0) { opts[k] = o[k]; } });
+    if (opts.popup === undefined) { opts.popup = simplestylePopup; }
+    var fcOf = function (f) { return { type: 'FeatureCollection', features: f }; };
+    if (areas.length) { this.addPolygons(id + ':areas', fcOf(areas), opts); this._layers[id + ':areas'].group = id; }
+    if (lines.length) { this.addLines(id + ':lines', fcOf(lines), opts); this._layers[id + ':lines'].group = id; }
+    if (points.length) { this.addPoints(id, fcOf(points), opts); this._layers[id].group = id; }
+  };
+
+  /** A layer's features as GeoJSON (a copy): an SDK layer, an addData group, or a style layer of a GeoJSON source. */
+  SMap.prototype.toGeoJSON = function (layerId) {
+    var self = this;
+    var members = this._order.filter(function (x) { return self._layers[x].group === layerId; });
+    if (members.length) {
+      var features = [];
+      [layerId + ':areas', layerId + ':lines', layerId].forEach(function (x) { if (members.indexOf(x) >= 0) { features = features.concat(clone(self._layers[x].data.features)); } });
+      return { type: 'FeatureCollection', features: features };
+    }
+    var def = this._layers[layerId];
+    if (def && def.kind !== 'style') { return clone(def.data); }
+    var source = def ? (typeof def.layer.source === 'object' ? def.layer.source : this._sources[def.layer.source]) : this._sources[layerId];
+    if (source && source.type === 'geojson' && source.data && typeof source.data === 'object') { return interop.formats.read(clone(source.data), { format: 'geojson' }); }
+    throw new Error('sMap: ' + layerId + ' has no GeoJSON features to give');
+  };
+
+  /** A layer's features as a KML document (text). */
+  SMap.prototype.toKML = function (layerId) { return interop.formats.toKML(this.toGeoJSON(layerId), { name: layerId }); };
+
+  /** Converts a file on sMap (POST /v1/convert) with this map's address, key and token: Promise of GeoJSON. */
+  SMap.prototype.convert = function (input, o) {
+    return interop.convert(input, Object.assign({ baseUrl: this._base, apiKey: this._apiKey, token: this._token }, o || {}));
+  };
+
+  /**
+   * sMap's raster tiles of a style as a `{z}/{x}/{y}` template on this map's node and key (M35), for tools without
+   * vector tiles. style: a scheme or `custom:<id>` (default: the map's own); o: {lang (default the map's language),
+   * retina}.
+   */
+  SMap.prototype.rasterUrl = function (style, o) {
+    o = o || {};
+    var name = style || this._serverStyle || this._flavor;
+    return interop.rasterUrl(name, { baseUrl: this._base, apiKey: this._apiKey || undefined, lang: o.lang || o.language || this._language, retina: !!o.retina });
+  };
+
+  // ------------------------------------------------------------------ external layers (M31)
+
+  var LAYER_PLACE = ['slot', 'before', 'zIndex'];
+  function placeOf(o) { var p = {}; LAYER_PLACE.forEach(function (k) { if (o[k] !== undefined) { p[k] = o[k]; } }); return p; }
+  function copyKeys(from, to, keys) { keys.forEach(function (k) { if (from[k] !== undefined) { to[k] = from[k]; } }); return to; }
+
+  SMap.prototype._addRaster = function (id, source, o) {
+    this.addSource(id, source);
+    var layer = copyKeys(o, { id: id, type: 'raster', source: id }, ['minzoom', 'maxzoom']);
+    if (o.opacity !== undefined) { layer.paint = { 'raster-opacity': o.opacity }; }
+    this.addStyleLayer(layer, placeOf(o));
+    this._layers[id].ownsSource = id;
+    return this;
+  };
+
+  /**
+   * Raster tiles from any XYZ template (`tiles` or `url` with {z}/{x}/{y}) or a TileJSON address (`url`).
+   * @param o {tiles, url, tileSize (256), attribution, minzoom, maxzoom, bounds, scheme, opacity, slot, before, zIndex}
+   */
+  SMap.prototype.addRasterLayer = function (id, o) {
+    o = o || {};
+    var source = { type: 'raster', tileSize: o.tileSize || 256 };
+    if (o.tiles) { source.tiles = Array.isArray(o.tiles) ? o.tiles.slice() : [o.tiles]; }
+    else if (o.url && /\{z\}/.test(o.url)) { source.tiles = [o.url]; }
+    else if (o.url) { source.url = o.url; }
+    else { throw new Error('sMap: addRasterLayer needs tiles or url'); }
+    copyKeys(o, source, ['attribution', 'minzoom', 'maxzoom', 'bounds', 'scheme']);
+    return this._addRaster(id, source, o);
+  };
+
+  /**
+   * An OGC WMS layer, one GetMap per tile in Web Mercator.
+   * @param o {url, layers, styles, format ('image/png'), transparent (true), version ('1.3.0' | '1.1.1'), params,
+   *           tileSize, attribution, opacity, minzoom, maxzoom, slot, before, zIndex}
+   */
+  SMap.prototype.addWmsLayer = function (id, o) {
+    o = o || {};
+    var source = copyKeys(o, { type: 'raster', tiles: [interop.wmsTileUrl(o)], tileSize: o.tileSize || 256 }, ['attribution', 'minzoom', 'maxzoom', 'bounds']);
+    return this._addRaster(id, source, o);
+  };
+
+  /**
+   * An OGC WMTS layer (Web Mercator matrix sets): from the GetCapabilities address (`url`, or its text as
+   * `capabilities`), KVP or REST; or from a REST template with {TileMatrix}, {TileRow}, {TileCol} (`url`).
+   * @param o {url, capabilities, layer, tileMatrixSet, style, format, encoding ('rest' | 'kvp'), attribution, opacity,
+   *           minzoom, maxzoom, slot, before, zIndex}
+   * @returns Promise of the map, once added
+   */
+  SMap.prototype.addWmtsLayer = function (id, o) {
+    var self = this;
+    o = o || {};
+    var url = o.url ? String(o.url) : '';
+    var add = function (source) { copyKeys(o, source, ['attribution', 'minzoom', 'maxzoom']); return self._addRaster(id, source, o); };
+    try {
+      if (/\{TileMatrix\}|\{TileRow\}|\{z\}/i.test(url)) {
+        var tile = url.replace(/\{TileMatrixSet\}/gi, o.tileMatrixSet || 'GoogleMapsCompatible').replace(/\{TileMatrix\}/gi, (o.matrixPrefix || '') + '{z}')
+          .replace(/\{TileRow\}/gi, '{y}').replace(/\{TileCol\}/gi, '{x}').replace(/\{Style\}/gi, o.style || 'default');
+        interop.refuseForbidden([tile]);
+        return Promise.resolve(add({ type: 'raster', tiles: [tile], tileSize: o.tileSize || 256 }));
+      }
+      if (o.capabilities) { return Promise.resolve(add(interop.wmtsSource(o.capabilities, o))); }
+    } catch (e) { return Promise.reject(e); }
+    if (!url) { return Promise.reject(new Error('sMap: addWmtsLayer needs url or capabilities')); }
+    var capsUrl = /request=getcapabilities/i.test(url) || /\.xml(\?|$)/i.test(url) ? url : url + (url.indexOf('?') < 0 ? '?' : '&') + 'SERVICE=WMTS&REQUEST=GetCapabilities';
+    try { interop.refuseForbidden([capsUrl]); } catch (e2) { return Promise.reject(e2); }
+    return fetch(capsUrl).then(function (res) {
+      if (!res.ok) { throw new Error('sMap: WMTS capabilities: HTTP ' + res.status); }
+      return res.text();
+    }).then(function (xml) { return add(interop.wmtsSource(xml, Object.assign({}, o, { url: url.split('?')[0] }))); });
+  };
+
+  /**
+   * Vector tiles (Mapbox Vector Tiles) from any address: `tiles` (templates), `url` (TileJSON, or a PMTiles archive
+   * ending in .pmtiles) or `pmtiles` (an archive address); drawn by your style layers (`layers`, their `source` set to
+   * this id when they name none).
+   * @param o {tiles, url, pmtiles, layers, attribution, minzoom, maxzoom, bounds, promoteId, slot, before, zIndex}
+   */
+  SMap.prototype.addVectorTiles = function (id, o) {
+    o = o || {};
+    var source = { type: 'vector' };
+    var archive = o.pmtiles || (o.url && (/^pmtiles:\/\//i.test(o.url) || /\.pmtiles(\?|$)/i.test(o.url)) ? o.url : null);
+    if (archive) { source.url = /^pmtiles:\/\//i.test(archive) ? archive : 'pmtiles://' + archive; }
+    else if (o.tiles) { source.tiles = Array.isArray(o.tiles) ? o.tiles.slice() : [o.tiles]; }
+    else if (o.url) { source.url = o.url; }
+    else { throw new Error('sMap: addVectorTiles needs tiles, url or pmtiles'); }
+    copyKeys(o, source, ['attribution', 'minzoom', 'maxzoom', 'bounds', 'promoteId', 'scheme']);
+    this.addSource(id, source);
+    var self = this, place = placeOf(o);
+    (o.layers || []).forEach(function (l) {
+      var layer = clone(l);
+      if (!layer.source) { layer.source = id; }
+      self.addStyleLayer(layer, place);
+    });
+    return this;
+  };
+
+  /**
+   * An ArcGIS REST service: a MapServer / ImageServer tile service (raster) or a VectorTileServer (vector tiles,
+   * drawn by `layers` or else by the service's own root style). The service's copyright text is its attribution
+   * unless `attribution` is given.
+   * @param o {url, layers, attribution, opacity, minzoom, maxzoom, slot, before, zIndex}
+   * @returns Promise of the map, once added
+   */
+  SMap.prototype.addArcGisLayer = function (id, o) {
+    var self = this;
+    o = o || {};
+    if (!o.url) { return Promise.reject(new Error('sMap: addArcGisLayer needs url')); }
+    var url = String(o.url).split('?')[0].replace(/\/+$/, '');
+    try { interop.refuseForbidden([url]); } catch (e) { return Promise.reject(e); }
+    var vector = /\/VectorTileServer$/i.test(url);
+    if (!vector && !/\/(MapServer|ImageServer)$/i.test(url)) { return Promise.reject(new Error('sMap: an ArcGIS address ends in /MapServer, /ImageServer or /VectorTileServer')); }
+    var json = function (u) { return typeof fetch === 'undefined' ? Promise.resolve({}) : fetch(u).then(function (r) { return r.ok ? r.json() : {}; }).catch(function () { return {}; }); };
+    return json(url + '?f=json').then(function (info) {
+      var attribution = o.attribution || (info && info.copyrightText) || undefined;
+      var opts = Object.assign({}, o, { attribution: attribution });
+      if (!vector) {
+        var tileSize = info && info.tileInfo && info.tileInfo.rows ? info.tileInfo.rows : 256;
+        var source = copyKeys(opts, { type: 'raster', tiles: [url + '/tile/{z}/{y}/{x}'], tileSize: tileSize }, ['attribution', 'minzoom', 'maxzoom']);
+        return self._addRaster(id, source, opts);
+      }
+      var layers = o.layers ? Promise.resolve(o.layers) : json(url + '/' + ((info && info.defaultStyles) || 'resources/styles') + '/root.json').then(function (st) { return (st && st.layers) || []; });
+      return layers.then(function (ls) {
+        var tiles = info && Array.isArray(info.tiles) && info.tiles.length ? info.tiles.map(function (t) { return /^https?:/.test(t) ? t : url + '/' + t; }) : [url + '/tile/{z}/{y}/{x}.pbf'];
+        self.addVectorTiles(id, Object.assign({}, opts, {
+          tiles: tiles,
+          layers: ls.map(function (l) { var c = clone(l); if (c.source) { c.source = id; } return c; }),
+        }));
+        return self;
+      });
+    });
+  };
+
+  // ------------------------------------------------------------------ deck.gl layers (M36, web only)
+
+  /**
+   * Draws a deck.gl layer interleaved with the basemap, through deck.gl's map overlay. deck.gl is optional: load it
+   * once with sMap.useDeck(await import('@deck.gl/mapbox')), or the global `deck` of its script build is used.
+   * A layer with the same id replaces the one before. o: {slot, before} places it (deck.gl's beforeId).
+   */
+  SMap.prototype.addDeckLayer = function (layer, o) {
+    var self = this;
+    if (!this.engine) { this.ready.then(function () { self.addDeckLayer(layer, o); }); return this; }
+    var d = interop.deck();
+    if (!d) { throw new Error('sMap: deck.gl is not loaded; call sMap.useDeck(await import("@deck.gl/mapbox")) first'); }
+    if (!layer || !layer.id) { throw new Error('sMap: addDeckLayer needs a deck.gl layer with an id'); }
+    o = o || {};
+    if ((o.slot || o.before) && typeof layer.clone === 'function') {
+      var anchor = o.before ? (this._layers[o.before] ? this._firstEngineLayer(o.before) : o.before) : this._groupAnchor(o.slot);
+      if (anchor) { layer = layer.clone({ beforeId: anchor }); }
+    }
+    this._deckLayers = this._deckLayers.filter(function (l) { return l.id !== layer.id; }).concat([layer]);
+    if (!this._deckOverlay) {
+      this._deckOverlay = new d.MapboxOverlay({ interleaved: true, layers: this._deckLayers.slice() });
+      this.engine.addControl(this._deckOverlay);
+    } else {
+      this._deckOverlay.setProps({ layers: this._deckLayers.slice() });
+    }
+    return this;
+  };
+
+  /**
+   * The map's deck.gl overlay (deck.gl's MapboxOverlay, interleaved with the basemap; one per map), made on first use.
+   * `props` are other deck.gl props of the overlay (getTooltip, onClick, pickingRadius, …); its layers stay the ones
+   * added with addDeckLayer (a `layers` prop is ignored). Returns null before the map is ready or when deck.gl is not
+   * loaded (sMap.useDeck).
+   */
+  SMap.prototype.deckOverlay = function (props) {
+    if (!this.engine) { return null; }
+    if (!this._deckOverlay) {
+      var d = interop.deck();
+      if (!d) { return null; }
+      this._deckOverlay = new d.MapboxOverlay({ interleaved: true, layers: this._deckLayers.slice() });
+      this.engine.addControl(this._deckOverlay);
+    }
+    if (props && typeof props === 'object') {
+      var own = {};
+      Object.keys(props).forEach(function (k) { if (k !== 'layers' && k !== 'interleaved') { own[k] = props[k]; } });
+      if (Object.keys(own).length) { this._deckOverlay.setProps(own); }
+    }
+    return this._deckOverlay;
+  };
+
+  /** Removes a deck.gl layer by its id. */
+  SMap.prototype.removeDeckLayer = function (id) {
+    this._deckLayers = this._deckLayers.filter(function (l) { return l.id !== id; });
+    if (this._deckOverlay) { this._deckOverlay.setProps({ layers: this._deckLayers.slice() }); }
+    return this;
+  };
+
+  /** The deck.gl layers on the map. */
+  SMap.prototype.deckLayers = function () { return this._deckLayers.slice(); };
+
+  // ------------------------------------------------------------------ layer description (M32, shared/LAYER-JSON.md)
+
+  var NOT_OPTIONS = ['slot', 'before', 'zIndex'];
+
+  /** The map's layers as the shared layer description (LAYER-JSON.md): basemap, sources, layers. */
+  SMap.prototype.toJSON = function () {
+    var self = this;
+    var out = { type: 'smap.layers', version: 1 };
+    if (!this._customStyle) { out.basemap = { style: this._serverStyle || this._flavor, language: this._language, overrides: clone(this._basemapOverrides) }; }
+    if (this._sourceOrder.length) { out.sources = this.sources(); }
+    out.layers = this._order.map(function (id) {
+      var def = self._layers[id];
+      var e = { id: id, kind: def.kind };
+      if (def.slot) { e.slot = def.slot; }
+      if (def.before) { e.before = def.before; }
+      if (def.zIndex) { e.zIndex = def.zIndex; }
+      if (def.hidden) { e.visible = false; }
+      if (def.group) { e.group = def.group; }
+      if (def.kind === 'style') { e.layer = clone(def.layer); return e; }
+      e.data = clone(def.data);
+      var options = {};
+      Object.keys(def.o).forEach(function (k) { if (NOT_OPTIONS.indexOf(k) < 0 && !(k === 'popup' && typeof def.o[k] !== 'string')) { options[k] = def.o[k]; } });
+      e.options = interop.jsonSafe(options);
+      return e;
+    });
+    return out;
+  };
+
+  /**
+   * Loads a layer description (LAYER-JSON.md, an object or its text): its basemap, sources and layers, each through
+   * the call that made it; an id already on the map is replaced, nothing else changes.
+   */
+  SMap.prototype.loadLayers = function (json) {
+    var self = this;
+    json = interop.checkLayerJson(json);
+    var b = json.basemap;
+    if (b) {
+      var style = b.style && b.style !== (this._serverStyle || this._flavor) ? b.style : null;
+      if (b.language) { this._language = b.language; }
+      if (style && this.engine) { this.setStyle(style); } else if (style) { this._takeStyle(style); }
+      else if (b.language && this.engine && !this._customStyle) { this.setLanguage(b.language); }
+      if (b.overrides) { this.setBasemap(b.overrides); }
+    }
+    Object.keys(json.sources || {}).forEach(function (id) { self.addSource(id, clone(json.sources[id])); });
+    json.layers.forEach(function (e) {
+      var place = {};
+      if (e.slot) { place.slot = e.slot; }
+      if (e.before) { place.before = e.before; }
+      if (e.zIndex) { place.zIndex = e.zIndex; }
+      if (e.kind === 'style') { self.addStyleLayer(e.layer, place); } else {
+        var opts = Object.assign({}, clone(e.options) || {}, place);
+        if (e.kind === 'points') { self.addPoints(e.id, e.data, opts); }
+        else if (e.kind === 'lines') { self.addLines(e.id, e.data, opts); }
+        else { self.addPolygons(e.id, e.data, opts); }
+      }
+      if (e.group && self._layers[e.id]) { self._layers[e.id].group = e.group; }
+      if (e.visible === false) { self.setVisible(e.id, false); }
+    });
+    return this;
+  };
+
   SMap.prototype._define = function (id, def) {
     if (this._layers[id]) { this._drop(id, this._layers[id]); }
+    var o = def.o;
+    if (o.slot !== undefined && o.slot !== null && SLOTS.indexOf(o.slot) < 0) { throw new Error('sMap: unknown slot "' + o.slot + '" (bottom, roads, labels, top)'); }
+    if (o.slot && o.before) { throw new Error('sMap: give a layer either slot or before'); }
+    def.slot = o.slot || null;
+    def.before = o.before || null;
+    def.popupFn = typeof o.popup === 'string' ? popupTemplate(o.popup) : null;
     def.zIndex = def.o.zIndex || 0;
     def.engineLayers = [];
     this._layers[id] = def;
@@ -27766,21 +29883,49 @@ function smapCreateSdk(engine) {
     return undefined;
   };
 
-  // The layer to insert before, so a higher zIndex always draws on top.
+  // Layers are drawn in groups: a slot, or under one named layer (`before`). A layer without either draws as in 1.0,
+  // on top, in the group of slot `top`.
+  function groupOf(def) { return def.before ? 'before:' + def.before : (def.slot || 'top'); }
+
+  // The layer to insert before: the next layer of the same group (so a higher zIndex always draws on top), else
+  // where the group begins.
   SMap.prototype._beforeId = function (id) {
-    var at = this._order.indexOf(id);
+    var at = this._order.indexOf(id), g = groupOf(this._layers[id]);
     for (var i = at + 1; i < this._order.length; i++) {
+      if (groupOf(this._layers[this._order[i]]) !== g) { continue; }
       var first = this._firstEngineLayer(this._order[i]);
       if (first) { return first; }
     }
-    return undefined;
+    return this._groupAnchor(g);
+  };
+
+  // Where a group begins: under a named layer (the SDK id of a layer, or any engine layer id), or the slot's first
+  // basemap layer (from the class table, so it stays put when the basemap's layer list changes).
+  SMap.prototype._groupAnchor = function (g) {
+    var m = this.engine;
+    if (g === 'top') { return undefined; }
+    if (g.indexOf('before:') === 0) {
+      var target = g.slice(7);
+      if (this._layers[target]) { return this._firstEngineLayer(target); }
+      return m.getLayer && m.getLayer(target) ? target : undefined;
+    }
+    var present = this._basemapIds.filter(function (x) { return m.getLayer && m.getLayer(x); });
+    var anchor = interop.slotAnchors(present)[g];
+    return anchor && m.getLayer(anchor) ? anchor : undefined;
+  };
+
+  /** Where each slot begins in the current basemap: {bottom, roads, labels, top} as layer ids (top: undefined). */
+  SMap.prototype.slots = function () {
+    var m = this.engine;
+    var present = this._basemapIds.filter(function (x) { return m && m.getLayer && m.getLayer(x); });
+    return interop.slotAnchors(present);
   };
 
   SMap.prototype._drop = function (id, def) {
     var m = this.engine;
     if (!m) { return; }
     def.engineLayers.forEach(function (l) { if (m.getLayer(l)) { m.removeLayer(l); } });
-    if (m.getSource('smap-' + id)) { m.removeSource('smap-' + id); }
+    if (def.kind !== 'style' && m.getSource('smap-' + id)) { m.removeSource('smap-' + id); }
     if (m.getSource('smap-' + id + '-hover')) { m.removeSource('smap-' + id + '-hover'); }
     def.hoverLayer = null; def.hovered = null;
     (this._handlers[id] || []).forEach(function (h) { if (h[1]) { m.off(h[0], h[1], h[2]); } else { m.off(h[0], h[2]); } });
@@ -27789,9 +29934,13 @@ function smapCreateSdk(engine) {
   };
 
   SMap.prototype._restore = function () {
-    var self = this;
+    var self = this, m = this.engine;
     if (this.engine.setProjection) { this.engine.setProjection({ type: this._projection }); }
     this._order.forEach(function (id) { self._layers[id].engineLayers = []; self._handlers[id] = []; });
+    this._snapshotBasemap();
+    this._applyBasemap();
+    Object.keys(this._basemapEdits).forEach(function (id) { self._applyEdits(id, self._basemapEdits[id]); });
+    this._sourceOrder.forEach(function (id) { if (!m.getSource(id)) { self._engineSource(id); } });
     this._applyBuildings();
     this._order.forEach(function (id) { self._add(id, self._layers[id]); });
   };
@@ -27799,8 +29948,17 @@ function smapCreateSdk(engine) {
   SMap.prototype._add = function (id, def) {
     var m = this.engine;
     var o = def.o;
-    var src = 'smap-' + id;
     var before = this._beforeId(id);
+    if (def.kind === 'style') {
+      // Passed to the engine as it is (a copy, so the engine never holds the object you gave).
+      var styleLayer = clone(def.layer);
+      if (def.hidden) { styleLayer.layout = Object.assign({}, styleLayer.layout || {}, { visibility: 'none' }); }
+      if (typeof styleLayer.source === 'string' && this._sources[styleLayer.source] && !m.getSource(styleLayer.source)) { this._engineSource(styleLayer.source); }
+      m.addLayer(styleLayer, before);
+      def.engineLayers.push(styleLayer.id);
+      return;
+    }
+    var src = 'smap-' + id;
     var range = {};
     if (o.minzoom !== undefined) { range.minzoom = o.minzoom; }
     if (o.maxzoom !== undefined) { range.maxzoom = o.maxzoom; }
@@ -27817,6 +29975,7 @@ function smapCreateSdk(engine) {
       // The engine refuses a filter key whose value is undefined (unclustered points have none).
       if (layer.filter === undefined) { delete layer.filter; }
       if (layer.minzoom === undefined) { delete layer.minzoom; }
+      if (layer.maxzoom === undefined) { delete layer.maxzoom; }
       if (layer.paint === undefined) { delete layer.paint; }
       // A layer's own minzoom (a marker's textMinzoom / badgeMinzoom) never shows it before the layer's own range.
       for (var k in range) { layer[k] = k === 'minzoom' && layer.minzoom !== undefined ? Math.max(layer.minzoom, range.minzoom) : range[k]; }
@@ -27854,7 +30013,7 @@ function smapCreateSdk(engine) {
         // Pins like Superroute's route map, drawn on the GPU: one image per colour pair (and per number, per badge),
         // made the first time a feature shows it. Numbers and badges are their own layers above the pins.
         var mk = o.marker;
-        var shape = mk.shape === 'circle' ? 'circle' : 'pin';
+        var shape = mk.shape === 'circle' || mk.shape === 'vehicle' ? mk.shape : 'pin';
         var size = mk.size || 32;
         var bw = mk.borderWidth !== undefined ? mk.borderWidth : 3;
         var g = markerGeometry(shape, size);
@@ -27865,22 +30024,29 @@ function smapCreateSdk(engine) {
         // Opacity of the pin, its number and its badge together (the route map draws settled stops at .72).
         var markerPaint = mk.opacity !== undefined ? { 'icon-opacity': valueExpr(mk.opacity, 1) } : undefined;
         main = src + '-points';
+        // From bakeZoom on (default 13) a pin's number is drawn into its own image, so an upper pin covers a lower
+        // one completely. Further out, where thousands of pins can be in view, the numbers stay one layer above the
+        // pins (an image per colour pair instead of per pin and number). bakeZoom: false keeps them separate.
+        var plainPin = drawnImageId('pin', [shape, str(mk.fill, '#ffffff'), str(mk.border, color), String(bw), String(size)]);
+        var bakeZoom = mk.text !== undefined && mk.bakeZoom !== false ? (mk.bakeZoom !== undefined ? mk.bakeZoom : 13) : null;
+        var pinImage = bakeZoom === null ? plainPin : ['step', ['zoom'], plainPin, bakeZoom,
+          drawnImageId('pinnum', [shape, str(mk.fill, '#ffffff'), str(mk.border, color), String(bw), String(size), str(mk.textColor, '#ffffff'), str(mk.text, '')])];
         var markerSpecs = [];
         var addMarker = function (layer) { markerSpecs.push(JSON.parse(JSON.stringify(layer))); add(layer); };
         addMarker({
           id: main, type: 'symbol', filter: only, paint: markerPaint,
           layout: {
-            'icon-image': drawnImageId('pin', [shape, str(mk.fill, '#ffffff'), str(mk.border, color), String(bw), String(size)]),
-            'icon-anchor': shape === 'circle' ? 'center' : 'bottom',
+            'icon-image': pinImage,
+            'icon-anchor': shape === 'pin' ? 'bottom' : 'center',
             // The image has room for the shadow below the tip: the tip, not the image's edge, is at the position.
-            'icon-offset': [0, shape === 'circle' ? 0 : PIN_PAD], 'icon-size': scale,
+            'icon-offset': [0, shape === 'pin' ? PIN_PAD : 0], 'icon-size': scale,
             'icon-allow-overlap': true, 'icon-ignore-placement': true,
           },
         });
         if (mk.text !== undefined) {
           var text = str(mk.text, '');
           addMarker({
-            id: src + '-numbers', type: 'symbol', filter: both(['!=', text, '']), minzoom: mk.textMinzoom, paint: markerPaint,
+            id: src + '-numbers', type: 'symbol', filter: both(['!=', text, '']), minzoom: mk.textMinzoom, maxzoom: bakeZoom === null ? undefined : bakeZoom, paint: markerPaint,
             layout: {
               'icon-image': drawnImageId('num', [str(mk.textColor, '#ffffff'), String(size), text]),
               'icon-offset': [0, -g.tipToHead], 'icon-size': scale, 'icon-allow-overlap': true, 'icon-ignore-placement': true,
@@ -27919,7 +30085,9 @@ function smapCreateSdk(engine) {
         add({
           id: main, type: 'circle', filter: only,
           paint: {
-            'circle-color': color, 'circle-radius': o.radius || 6,
+            // simplestyle (marker-color, marker-size) when the layer gives no colour / size of its own
+            'circle-color': o.color ? color : ['to-color', ['get', 'marker-color'], color],
+            'circle-radius': o.radius || (o.color ? 6 : ['match', ['get', 'marker-size'], 'small', 4, 'large', 9, 6]),
             'circle-stroke-width': o.strokeWidth !== undefined ? o.strokeWidth : 1.5, 'circle-stroke-color': o.strokeColor || '#ffffff',
           },
         });
@@ -27927,13 +30095,17 @@ function smapCreateSdk(engine) {
       if (o.label) {
         add({
           id: src + '-labels', type: 'symbol', filter: only,
-          layout: { 'text-field': ['to-string', ['get', o.label]], 'text-font': ['Noto Sans Regular'], 'text-size': 12, 'text-offset': [0, 1.2], 'text-anchor': 'top', 'text-optional': true },
+          layout: o.labelPosition === 'right'
+            ? { 'text-field': ['to-string', ['get', o.label]], 'text-font': ['Noto Sans Regular'], 'text-size': 11, 'text-offset': [1.3, 0], 'text-anchor': 'left', 'text-optional': true, 'text-max-width': 12 }
+            : { 'text-field': ['to-string', ['get', o.label]], 'text-font': ['Noto Sans Regular'], 'text-size': 12, 'text-offset': [0, 1.2], 'text-anchor': 'top', 'text-optional': true },
           paint: { 'text-color': '#1f2937', 'text-halo-color': '#ffffff', 'text-halo-width': 1.4 },
         });
       }
     } else if (def.kind === 'lines') {
       main = src + '-lines';
-      var lineColor = valueExpr(o.color, '#4f46e5');
+      // simplestyle (stroke, stroke-width, stroke-opacity) when the layer gives no colour of its own
+      var simple = o.color === undefined || o.color === null;
+      var lineColor = simple ? ['to-color', ['get', 'stroke'], '#4f46e5'] : valueExpr(o.color, '#4f46e5');
       var round = { 'line-cap': 'round', 'line-join': 'round' };
       // Bottom to top: casing, shadow, the line, its arrows (as on Superroute's route map).
       if (o.casing) {
@@ -27946,7 +30118,11 @@ function smapCreateSdk(engine) {
         add({ id: src + '-shadow', type: 'line', layout: round, paint: {
           'line-color': valueExpr(sh.color, '#000000'), 'line-width': sh.width || 7, 'line-opacity': sh.opacity !== undefined ? sh.opacity : 0.3 } });
       }
-      var paint = { 'line-color': lineColor, 'line-width': o.width || 3, 'line-opacity': o.opacity !== undefined ? o.opacity : 1 };
+      var paint = {
+        'line-color': lineColor,
+        'line-width': o.width || (simple ? numberProp('stroke-width', 3) : 3),
+        'line-opacity': o.opacity !== undefined ? o.opacity : (simple ? numberProp('stroke-opacity', 1) : 1),
+      };
       if (o.dash) { paint['line-dasharray'] = o.dash; }
       add({ id: main, type: 'line', layout: round, paint: paint });
       if (o.arrows) {
@@ -27977,8 +30153,16 @@ function smapCreateSdk(engine) {
         });
       } else {
         main = src + '-fill';
-        add({ id: main, type: 'fill', paint: { 'fill-color': o.fill || color, 'fill-opacity': o.opacity !== undefined ? o.opacity : 0.25 } });
-        add({ id: src + '-outline', type: 'line', paint: { 'line-color': o.outline || o.fill || color, 'line-width': o.outlineWidth || 1.5 } });
+        if (!o.fill && !o.color) {
+          // simplestyle (fill, fill-opacity, stroke, stroke-width, stroke-opacity) when the layer gives no colour
+          add({ id: main, type: 'fill', paint: { 'fill-color': ['to-color', ['get', 'fill'], color], 'fill-opacity': o.opacity !== undefined ? o.opacity : numberProp('fill-opacity', 0.25) } });
+          add({ id: src + '-outline', type: 'line', paint: {
+            'line-color': o.outline || ['to-color', ['get', 'stroke'], ['get', 'fill'], color],
+            'line-width': o.outlineWidth || numberProp('stroke-width', 1.5), 'line-opacity': numberProp('stroke-opacity', 1) } });
+        } else {
+          add({ id: main, type: 'fill', paint: { 'fill-color': o.fill || color, 'fill-opacity': o.opacity !== undefined ? o.opacity : 0.25 } });
+          add({ id: src + '-outline', type: 'line', paint: { 'line-color': o.outline || o.fill || color, 'line-width': o.outlineWidth || 1.5 } });
+        }
       }
     }
     // The popup is opened by the map's one click handler (_popupClick), from this layer's own hit test.
@@ -28009,6 +30193,7 @@ function smapCreateSdk(engine) {
       if (layer.filter === undefined) { delete layer.filter; }
       if (layer.paint === undefined) { delete layer.paint; }
       if (layer.minzoom === undefined) { delete layer.minzoom; }
+      if (layer.maxzoom === undefined) { delete layer.maxzoom; }
       m.addLayer(layer);
       def.engineLayers.push(layer.id);
       if (!top) { top = layer.id; }
@@ -28048,10 +30233,24 @@ function smapCreateSdk(engine) {
     (this._handlers[id] = this._handlers[id] || []).push([type, layer, fn]);
   };
 
-  return { Map: SMap, version: VERSION, styles: FLAVORS.slice(), engine: engine, popupTemplate: popupTemplate };
+  return {
+    Map: SMap, version: VERSION, styles: FLAVORS.slice(), engine: engine, popupTemplate: popupTemplate,
+    slots: SLOTS.slice(),
+    formats: interop.formats,
+    convert: interop.convert,
+    rasterUrl: interop.rasterUrl,
+    rasterTileJsonUrl: interop.rasterTileJsonUrl,
+    styleUrl: interop.styleUrl,
+    applyBasemapOverrides: interop.applyBasemapOverrides,
+    basemapClasses: interop.basemapClasses,
+    slotAnchors: interop.slotAnchors,
+    parseWmtsCapabilities: interop.parseWmtsCapabilities,
+    PMTilesArchive: interop.PMTilesArchive,
+    useDeck: interop.useDeck,
+  };
 });
 
   return module.exports;
 }
-(typeof globalThis !== 'undefined' ? globalThis : window).sMap = smapCreateSdk(smapCreateEngine());
+(typeof globalThis !== 'undefined' ? globalThis : window).sMap = smapCreateSdk(smapCreateEngine(), smapCreateInterop());
 })();