@basemaps/cli-vector 8.3.0 → 8.4.0

package/dist/index.cjs

@@ -65691,14 +65691,14 @@ var require_polygon_clipping_cjs = __commonJS({
             if (windingsAfter[_i] === 0)
               continue;
             var _ring = ringsAfter[_i];
-            var poly = _ring.poly;
-            if (polysExclude.indexOf(poly) !== -1)
+            var poly2 = _ring.poly;
+            if (polysExclude.indexOf(poly2) !== -1)
               continue;
             if (_ring.isExterior)
-              polysAfter.push(poly);
+              polysAfter.push(poly2);
             else {
-              if (polysExclude.indexOf(poly) === -1)
-                polysExclude.push(poly);
+              if (polysExclude.indexOf(poly2) === -1)
+                polysExclude.push(poly2);
               var _index = polysAfter.indexOf(_ring.poly);
               if (_index !== -1)
                 polysAfter.splice(_index, 1);
@@ -65781,12 +65781,12 @@ var require_polygon_clipping_cjs = __commonJS({
       return Segment2;
     }();
     var RingIn = /* @__PURE__ */ function() {
-      function RingIn2(geomRing, poly, isExterior) {
+      function RingIn2(geomRing, poly2, isExterior) {
         _classCallCheck(this, RingIn2);
         if (!Array.isArray(geomRing) || geomRing.length === 0) {
           throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
         }
-        this.poly = poly;
+        this.poly = poly2;
         this.isExterior = isExterior;
         this.segments = [];
         if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") {
@@ -65910,16 +65910,16 @@ var require_polygon_clipping_cjs = __commonJS({
           }
         };
         for (var i = 0, iMax = geom.length; i < iMax; i++) {
-          var poly = new PolyIn(geom[i], this);
-          if (poly.bbox.ll.x < this.bbox.ll.x)
-            this.bbox.ll.x = poly.bbox.ll.x;
-          if (poly.bbox.ll.y < this.bbox.ll.y)
-            this.bbox.ll.y = poly.bbox.ll.y;
-          if (poly.bbox.ur.x > this.bbox.ur.x)
-            this.bbox.ur.x = poly.bbox.ur.x;
-          if (poly.bbox.ur.y > this.bbox.ur.y)
-            this.bbox.ur.y = poly.bbox.ur.y;
-          this.polys.push(poly);
+          var poly2 = new PolyIn(geom[i], this);
+          if (poly2.bbox.ll.x < this.bbox.ll.x)
+            this.bbox.ll.x = poly2.bbox.ll.x;
+          if (poly2.bbox.ll.y < this.bbox.ll.y)
+            this.bbox.ll.y = poly2.bbox.ll.y;
+          if (poly2.bbox.ur.x > this.bbox.ur.x)
+            this.bbox.ur.x = poly2.bbox.ur.x;
+          if (poly2.bbox.ur.y > this.bbox.ur.y)
+            this.bbox.ur.y = poly2.bbox.ur.y;
+          this.polys.push(poly2);
         }
         this.isSubject = isSubject;
       }
@@ -70677,7 +70677,7 @@ var require_proj4_src = __commonJS({
         return p;
       }
       var names$19 = ["Polyconic", "poly"];
-      var poly = {
+      var poly2 = {
         init: init$18,
         forward: forward$17,
         inverse: inverse$17,
@@ -72157,7 +72157,7 @@ var require_proj4_src = __commonJS({
         proj4.Proj.projections.add(gnom);
         proj4.Proj.projections.add(cea);
         proj4.Proj.projections.add(eqc);
-        proj4.Proj.projections.add(poly);
+        proj4.Proj.projections.add(poly2);
         proj4.Proj.projections.add(nzmg);
         proj4.Proj.projections.add(mill);
         proj4.Proj.projections.add(sinu);
@@ -72643,6 +72643,225 @@ var require_src3 = __commonJS({
   }
 });
 
+// node_modules/tinyqueue/tinyqueue.js
+var require_tinyqueue = __commonJS({
+  "node_modules/tinyqueue/tinyqueue.js"(exports, module2) {
+    (function(global2, factory) {
+      typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = global2 || self, global2.TinyQueue = factory());
+    })(exports, function() {
+      "use strict";
+      var TinyQueue = function TinyQueue2(data, compare) {
+        if (data === void 0)
+          data = [];
+        if (compare === void 0)
+          compare = defaultCompare;
+        this.data = data;
+        this.length = this.data.length;
+        this.compare = compare;
+        if (this.length > 0) {
+          for (var i = (this.length >> 1) - 1; i >= 0; i--) {
+            this._down(i);
+          }
+        }
+      };
+      TinyQueue.prototype.push = function push2(item) {
+        this.data.push(item);
+        this.length++;
+        this._up(this.length - 1);
+      };
+      TinyQueue.prototype.pop = function pop() {
+        if (this.length === 0) {
+          return void 0;
+        }
+        var top = this.data[0];
+        var bottom = this.data.pop();
+        this.length--;
+        if (this.length > 0) {
+          this.data[0] = bottom;
+          this._down(0);
+        }
+        return top;
+      };
+      TinyQueue.prototype.peek = function peek() {
+        return this.data[0];
+      };
+      TinyQueue.prototype._up = function _up(pos) {
+        var ref = this;
+        var data = ref.data;
+        var compare = ref.compare;
+        var item = data[pos];
+        while (pos > 0) {
+          var parent = pos - 1 >> 1;
+          var current = data[parent];
+          if (compare(item, current) >= 0) {
+            break;
+          }
+          data[pos] = current;
+          pos = parent;
+        }
+        data[pos] = item;
+      };
+      TinyQueue.prototype._down = function _down(pos) {
+        var ref = this;
+        var data = ref.data;
+        var compare = ref.compare;
+        var halfLength = this.length >> 1;
+        var item = data[pos];
+        while (pos < halfLength) {
+          var left = (pos << 1) + 1;
+          var best = data[left];
+          var right = left + 1;
+          if (right < this.length && compare(data[right], best) < 0) {
+            left = right;
+            best = data[right];
+          }
+          if (compare(best, item) >= 0) {
+            break;
+          }
+          data[pos] = best;
+          pos = left;
+        }
+        data[pos] = item;
+      };
+      function defaultCompare(a, b) {
+        return a < b ? -1 : a > b ? 1 : 0;
+      }
+      return TinyQueue;
+    });
+  }
+});
+
+// node_modules/polylabel/polylabel.js
+var require_polylabel = __commonJS({
+  "node_modules/polylabel/polylabel.js"(exports, module2) {
+    "use strict";
+    var Queue2 = require_tinyqueue();
+    if (Queue2.default)
+      Queue2 = Queue2.default;
+    module2.exports = polylabel2;
+    module2.exports.default = polylabel2;
+    function polylabel2(polygon, precision, debug) {
+      precision = precision || 1;
+      var minX, minY, maxX, maxY;
+      for (var i = 0; i < polygon[0].length; i++) {
+        var p = polygon[0][i];
+        if (!i || p[0] < minX)
+          minX = p[0];
+        if (!i || p[1] < minY)
+          minY = p[1];
+        if (!i || p[0] > maxX)
+          maxX = p[0];
+        if (!i || p[1] > maxY)
+          maxY = p[1];
+      }
+      var width = maxX - minX;
+      var height = maxY - minY;
+      var cellSize = Math.min(width, height);
+      var h = cellSize / 2;
+      if (cellSize === 0) {
+        var degeneratePoleOfInaccessibility = [minX, minY];
+        degeneratePoleOfInaccessibility.distance = 0;
+        return degeneratePoleOfInaccessibility;
+      }
+      var cellQueue = new Queue2(void 0, compareMax);
+      for (var x = minX; x < maxX; x += cellSize) {
+        for (var y = minY; y < maxY; y += cellSize) {
+          cellQueue.push(new Cell(x + h, y + h, h, polygon));
+        }
+      }
+      var bestCell = getCentroidCell(polygon);
+      var bboxCell = new Cell(minX + width / 2, minY + height / 2, 0, polygon);
+      if (bboxCell.d > bestCell.d)
+        bestCell = bboxCell;
+      var numProbes = cellQueue.length;
+      while (cellQueue.length) {
+        var cell = cellQueue.pop();
+        if (cell.d > bestCell.d) {
+          bestCell = cell;
+          if (debug)
+            console.log("found best %d after %d probes", Math.round(1e4 * cell.d) / 1e4, numProbes);
+        }
+        if (cell.max - bestCell.d <= precision)
+          continue;
+        h = cell.h / 2;
+        cellQueue.push(new Cell(cell.x - h, cell.y - h, h, polygon));
+        cellQueue.push(new Cell(cell.x + h, cell.y - h, h, polygon));
+        cellQueue.push(new Cell(cell.x - h, cell.y + h, h, polygon));
+        cellQueue.push(new Cell(cell.x + h, cell.y + h, h, polygon));
+        numProbes += 4;
+      }
+      if (debug) {
+        console.log("num probes: " + numProbes);
+        console.log("best distance: " + bestCell.d);
+      }
+      var poleOfInaccessibility = [bestCell.x, bestCell.y];
+      poleOfInaccessibility.distance = bestCell.d;
+      return poleOfInaccessibility;
+    }
+    function compareMax(a, b) {
+      return b.max - a.max;
+    }
+    function Cell(x, y, h, polygon) {
+      this.x = x;
+      this.y = y;
+      this.h = h;
+      this.d = pointToPolygonDist(x, y, polygon);
+      this.max = this.d + this.h * Math.SQRT2;
+    }
+    function pointToPolygonDist(x, y, polygon) {
+      var inside = false;
+      var minDistSq = Infinity;
+      for (var k = 0; k < polygon.length; k++) {
+        var ring = polygon[k];
+        for (var i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
+          var a = ring[i];
+          var b = ring[j];
+          if (a[1] > y !== b[1] > y && x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0])
+            inside = !inside;
+          minDistSq = Math.min(minDistSq, getSegDistSq(x, y, a, b));
+        }
+      }
+      return minDistSq === 0 ? 0 : (inside ? 1 : -1) * Math.sqrt(minDistSq);
+    }
+    function getCentroidCell(polygon) {
+      var area = 0;
+      var x = 0;
+      var y = 0;
+      var points = polygon[0];
+      for (var i = 0, len = points.length, j = len - 1; i < len; j = i++) {
+        var a = points[i];
+        var b = points[j];
+        var f = a[0] * b[1] - b[0] * a[1];
+        x += (a[0] + b[0]) * f;
+        y += (a[1] + b[1]) * f;
+        area += f * 3;
+      }
+      if (area === 0)
+        return new Cell(points[0][0], points[0][1], 0, polygon);
+      return new Cell(x / area, y / area, 0, polygon);
+    }
+    function getSegDistSq(px, py, a, b) {
+      var x = a[0];
+      var y = a[1];
+      var dx = b[0] - x;
+      var dy = b[1] - y;
+      if (dx !== 0 || dy !== 0) {
+        var t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+          x = b[0];
+          y = b[1];
+        } else if (t > 0) {
+          x += dx * t;
+          y += dy * t;
+        }
+      }
+      dx = px - x;
+      dy = py - y;
+      return dx * dx + dy * dy;
+    }
+  }
+});
+
 // ../../node_modules/readable-stream/lib/internal/streams/stream.js
 var require_stream2 = __commonJS({
   "../../node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module2) {
@@ -80329,9 +80548,9 @@ var ulid2 = __toESM(require_index_umd(), 1);
 var CliInfo = {
   // Detect unlinked packages looks for this string since its a package name, slightly work around it
   package: "@basemaps/cli",
-  version: "v8.3.0",
-  hash: "fe8bbf9d0a3ca2f590505924f227a6d9da0ea5a8",
-  buildId: "15719849199-1"
+  version: "v8.4.0",
+  hash: "f30c12a7491ec5556f62b3f35d985d2e89a15c39",
+  buildId: "15866391498-1"
 };
 var CliDate = (/* @__PURE__ */ new Date()).toISOString();
 var CliId = ulid2.ulid();
@@ -86582,8 +86801,8 @@ var Bounds = class _Bounds {
     let minY = multipoly[0][0][0][1];
     let maxX = minX;
     let maxY = minY;
-    for (const [poly] of multipoly) {
-      for (const [x, y] of poly) {
+    for (const [poly2] of multipoly) {
+      for (const [x, y] of poly2) {
         if (x < minX)
           minX = x;
         else if (x > maxX)
@@ -86807,8 +87026,8 @@ function removeDegenerateEdges(polygons, bbox) {
 }
 function clipMultipolygon(polygons, bbox) {
   const result = [];
-  for (const poly of polygons) {
-    const clipped = import_lineclip.default.polygon(poly[0], bbox);
+  for (const poly2 of polygons) {
+    const clipped = import_lineclip.default.polygon(poly2[0], bbox);
     if (clipped.length !== 0) {
       if (!samePoint(clipped[0], clipped[clipped.length - 1]))
         clipped.push(clipped[0]);
@@ -86965,10 +87184,10 @@ var Wgs84 = {
        */
   multiPolygonToBbox(multipolygon) {
     let ans = null;
-    for (const poly of multipolygon) {
-      if (poly.length === 0)
+    for (const poly2 of multipolygon) {
+      if (poly2.length === 0)
         continue;
-      const ring = poly[0];
+      const ring = poly2[0];
       if (ring.length < 3)
         continue;
       const bbox = this.ringToBbox(ring);
@@ -87004,11 +87223,11 @@ function pointAtFrac(frac, a, b) {
 }
 function splitWgs84MultiPolygon(multipoly) {
   const result = [];
-  for (const poly of clipMultipolygon(multipoly, WorldBounds)) {
-    result.push(poly);
+  for (const poly2 of clipMultipolygon(multipoly, WorldBounds)) {
+    result.push(poly2);
   }
-  for (const poly of clipMultipolygon(multipoly, NextWorldBounds)) {
-    result.push(poly.map((ring) => ring.map((point) => [point[0] - 360, point[1]])));
+  for (const poly2 of clipMultipolygon(multipoly, NextWorldBounds)) {
+    result.push(poly2.map((ring) => ring.map((point) => [point[0] - 360, point[1]])));
   }
   return result;
 }
@@ -87199,7 +87418,7 @@ var Projection = class _Projection {
       return multipoly;
     const { toWgs84 } = this;
     const { fromWgs84 } = targetProjection;
-    return multipoly.map((poly) => poly.map((ring) => ring.map((p) => fromWgs84(toWgs84(p)))));
+    return multipoly.map((poly2) => poly2.map((ring) => ring.map((p) => fromWgs84(toWgs84(p)))));
   }
   /**
    * Convert source `[x, y]` coordinates to `[lon, lat]`
@@ -87920,8 +88139,8 @@ function locationTransform(location, tileMatrix, targetTileMatrix) {
 }
 function projectFeature(f, targetTileMatrix) {
   if (f.geometry.type === "Polygon") {
-    for (const poly of f.geometry.coordinates) {
-      for (const coord of poly) {
+    for (const poly2 of f.geometry.coordinates) {
+      for (const coord of poly2) {
         const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
         coord[0] = output.lon;
         coord[1] = output.lat;
@@ -87929,8 +88148,8 @@ function projectFeature(f, targetTileMatrix) {
     }
   } else if (f.geometry.type === "MultiPolygon") {
     for (const multiPoly of f.geometry.coordinates) {
-      for (const poly of multiPoly) {
-        for (const coord of poly) {
+      for (const poly2 of multiPoly) {
+        for (const coord of poly2) {
           const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
           coord[0] = output.lon;
           coord[1] = output.lat;
@@ -90567,6 +90786,7 @@ var VectorStac = class {
         ...layers
       ],
       properties: {
+        datetime: CliDate,
         "proj:epsg": tileMatrix.projection.code,
         "linz_basemaps:generated": {
           package: CliInfo.package,
@@ -90649,7 +90869,7 @@ async function createStacFiles(filePaths, targetPath, filename, tileMatrix, titl
   };
   const stacCollection = vectorStac.createStacCollection(unionBbox, layers, filename, title);
   let stacCatalog = vectorStac.createStacCatalog();
-  const catalogPath = new URL("catalog.json", targetPath);
+  const catalogPath = new URL("topographic/catalog.json", targetPath);
   if (await Fsa.exists(catalogPath))
     stacCatalog = await Fsa.readJson(catalogPath);
   stacCatalog.links.push({
@@ -90961,93 +91181,79 @@ function handleKindPeak(feature, logger) {
 }
 
 // src/modify/parser.ts
+var optionalString = z.preprocess((value) => {
+  if (value === "0" || value === null) {
+    return void 0;
+  } else {
+    return value;
+  }
+}, z.string().optional());
 var zPlaceLabelsProperties = z.object({
   /** @example "Kaitaia" */
   label: z.string(),
+  /** @example 8 */
+  zoom_level: z.number(),
   /** @example "TWN1" */
   style: z.string(),
+  /** @example "cape" */
+  natural: optionalString,
   /** @example "city" */
-  place: z.string(),
-  /** @example 7 */
-  adminlevel: z.number(),
-  /** @example "0" */
-  natural: z.string(),
-  /** @example "0" */
-  water: z.string()
-});
-var zPlaceLabelsTippecanoe = z.object({
-  /** @example "place_labels" */
-  layer: z.string(),
-  /** @example 8 */
-  minzoom: z.number(),
-  /** @example 8 */
-  maxzoom: z.number()
+  place: optionalString,
+  /** @example "bay" */
+  water: optionalString
 });
 
 // src/modify/layers/place_labels.ts
 var PlaceLabelsFeatures = /* @__PURE__ */ new Map();
 function handleLayerPlaceLabels(feature, logger) {
   logger.trace({}, "HandlePlaceLabels:Start");
-  feature = structuredClone(feature);
-  const label = feature.properties["label"];
-  if (typeof label !== "string")
-    throw new Error("Label property is not a string");
-  const zoomLevel = feature.properties["zoom_level"];
-  if (typeof zoomLevel !== "number")
-    throw new Error("Zoom level is not a number");
-  const storedFeature = PlaceLabelsFeatures.get(label);
+  const newFeature = createNewFeature(feature, logger);
+  const name = newFeature.properties.name;
+  const storedFeature = PlaceLabelsFeatures.get(name);
   if (storedFeature == null) {
-    const newFeature = createNewFeature(feature, label, zoomLevel, logger);
-    if (newFeature == null)
-      return null;
-    PlaceLabelsFeatures.set(label, newFeature);
+    PlaceLabelsFeatures.set(name, newFeature);
     logger.trace({}, "HandlePlaceLabels:End");
     return newFeature;
   }
-  storedFeature.tippecanoe.minzoom = zoomLevel;
-  storedFeature.tippecanoe.maxzoom = zoomLevel;
+  storedFeature.tippecanoe.minzoom = newFeature.tippecanoe.minzoom;
+  storedFeature.tippecanoe.maxzoom = newFeature.tippecanoe.minzoom;
   logger.trace({}, "HandlePlaceLabels:End");
-  return storedFeature;
+  return structuredClone(storedFeature);
 }
-function createNewFeature(feature, label, zoomLevel, logger) {
-  let properties;
-  let tippecanoe2;
+function createNewFeature(feature, logger) {
   try {
-    properties = zPlaceLabelsProperties.parse({
-      label,
+    const properties = zPlaceLabelsProperties.parse({
+      label: feature.properties["label"],
+      zoom_level: feature.properties["zoom_level"],
       style: feature.properties["style"],
-      place: feature.properties["place"],
-      adminlevel: feature.properties["adminlevel"],
       natural: feature.properties["natural"],
+      place: feature.properties["place"],
       water: feature.properties["water"]
     });
-    tippecanoe2 = zPlaceLabelsTippecanoe.parse({
+    const tippecanoe2 = {
       layer: "place_labels",
-      minzoom: zoomLevel,
-      maxzoom: zoomLevel
-    });
+      minzoom: properties.zoom_level,
+      maxzoom: properties.zoom_level
+    };
+    const newFeature = {
+      type: feature.type,
+      properties: {
+        name: properties.label,
+        kind: convertStyleToKind(properties.style, tippecanoe2.minzoom),
+        natural: properties.natural,
+        place: properties.place,
+        water: properties.water
+      },
+      geometry: feature.geometry,
+      tippecanoe: tippecanoe2
+    };
+    return newFeature;
   } catch (e) {
     if (e instanceof z.ZodError) {
-      logger.trace({ label }, "Failed to parse expected properties. Discarding feature.");
-      return null;
-    } else {
-      throw new Error("An unexpected error occurred.");
-    }
-  }
-  const newFeature = {
-    type: feature.type,
-    properties: {
-      name: properties.label,
-      kind: convertStyleToKind(properties.style, tippecanoe2.minzoom),
-      place: properties.place,
-      adminlevel: properties.adminlevel,
-      natural: properties.natural,
-      water: properties.water
-    },
-    geometry: feature.geometry,
-    tippecanoe: tippecanoe2
-  };
-  return newFeature;
+      logger.trace({ properties: feature.properties }, "Failed to parse required properties.");
+    }
+    throw e;
+  }
 }
 function convertStyleToKind(style, minzoom) {
   if (style.startsWith("ANT"))
@@ -91067,190 +91273,8 @@ function convertStyleToKind(style, minzoom) {
   return "";
 }
 
-// ../../node_modules/tinyqueue/index.js
-var TinyQueue = class {
-  constructor(data = [], compare = (a, b) => a < b ? -1 : a > b ? 1 : 0) {
-    this.data = data;
-    this.length = this.data.length;
-    this.compare = compare;
-    if (this.length > 0) {
-      for (let i = (this.length >> 1) - 1; i >= 0; i--)
-        this._down(i);
-    }
-  }
-  push(item) {
-    this.data.push(item);
-    this._up(this.length++);
-  }
-  pop() {
-    if (this.length === 0)
-      return void 0;
-    const top = this.data[0];
-    const bottom = this.data.pop();
-    if (--this.length > 0) {
-      this.data[0] = bottom;
-      this._down(0);
-    }
-    return top;
-  }
-  peek() {
-    return this.data[0];
-  }
-  _up(pos) {
-    const { data, compare } = this;
-    const item = data[pos];
-    while (pos > 0) {
-      const parent = pos - 1 >> 1;
-      const current = data[parent];
-      if (compare(item, current) >= 0)
-        break;
-      data[pos] = current;
-      pos = parent;
-    }
-    data[pos] = item;
-  }
-  _down(pos) {
-    const { data, compare } = this;
-    const halfLength = this.length >> 1;
-    const item = data[pos];
-    while (pos < halfLength) {
-      let bestChild = (pos << 1) + 1;
-      const right = bestChild + 1;
-      if (right < this.length && compare(data[right], data[bestChild]) < 0) {
-        bestChild = right;
-      }
-      if (compare(data[bestChild], item) >= 0)
-        break;
-      data[pos] = data[bestChild];
-      pos = bestChild;
-    }
-    data[pos] = item;
-  }
-};
-
-// ../../node_modules/polylabel/polylabel.js
-function polylabel(polygon, precision = 1, debug = false) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const [x, y] of polygon[0]) {
-    if (x < minX)
-      minX = x;
-    if (y < minY)
-      minY = y;
-    if (x > maxX)
-      maxX = x;
-    if (y > maxY)
-      maxY = y;
-  }
-  const width = maxX - minX;
-  const height = maxY - minY;
-  const cellSize = Math.max(precision, Math.min(width, height));
-  if (cellSize === precision) {
-    const result2 = [minX, minY];
-    result2.distance = 0;
-    return result2;
-  }
-  const cellQueue = new TinyQueue([], (a, b) => b.max - a.max);
-  let bestCell = getCentroidCell(polygon);
-  const bboxCell = new Cell(minX + width / 2, minY + height / 2, 0, polygon);
-  if (bboxCell.d > bestCell.d)
-    bestCell = bboxCell;
-  let numProbes = 2;
-  function potentiallyQueue(x, y, h2) {
-    const cell = new Cell(x, y, h2, polygon);
-    numProbes++;
-    if (cell.max > bestCell.d + precision)
-      cellQueue.push(cell);
-    if (cell.d > bestCell.d) {
-      bestCell = cell;
-      if (debug)
-        console.log(`found best ${Math.round(1e4 * cell.d) / 1e4} after ${numProbes} probes`);
-    }
-  }
-  let h = cellSize / 2;
-  for (let x = minX; x < maxX; x += cellSize) {
-    for (let y = minY; y < maxY; y += cellSize) {
-      potentiallyQueue(x + h, y + h, h);
-    }
-  }
-  while (cellQueue.length) {
-    const { max, x, y, h: ch } = cellQueue.pop();
-    if (max - bestCell.d <= precision)
-      break;
-    h = ch / 2;
-    potentiallyQueue(x - h, y - h, h);
-    potentiallyQueue(x + h, y - h, h);
-    potentiallyQueue(x - h, y + h, h);
-    potentiallyQueue(x + h, y + h, h);
-  }
-  if (debug) {
-    console.log(`num probes: ${numProbes}
-best distance: ${bestCell.d}`);
-  }
-  const result = [bestCell.x, bestCell.y];
-  result.distance = bestCell.d;
-  return result;
-}
-function Cell(x, y, h, polygon) {
-  this.x = x;
-  this.y = y;
-  this.h = h;
-  this.d = pointToPolygonDist(x, y, polygon);
-  this.max = this.d + this.h * Math.SQRT2;
-}
-function pointToPolygonDist(x, y, polygon) {
-  let inside = false;
-  let minDistSq = Infinity;
-  for (const ring of polygon) {
-    for (let i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
-      const a = ring[i];
-      const b = ring[j];
-      if (a[1] > y !== b[1] > y && x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0])
-        inside = !inside;
-      minDistSq = Math.min(minDistSq, getSegDistSq(x, y, a, b));
-    }
-  }
-  return minDistSq === 0 ? 0 : (inside ? 1 : -1) * Math.sqrt(minDistSq);
-}
-function getCentroidCell(polygon) {
-  let area = 0;
-  let x = 0;
-  let y = 0;
-  const points = polygon[0];
-  for (let i = 0, len = points.length, j = len - 1; i < len; j = i++) {
-    const a = points[i];
-    const b = points[j];
-    const f = a[0] * b[1] - b[0] * a[1];
-    x += (a[0] + b[0]) * f;
-    y += (a[1] + b[1]) * f;
-    area += f * 3;
-  }
-  const centroid = new Cell(x / area, y / area, 0, polygon);
-  if (area === 0 || centroid.d < 0)
-    return new Cell(points[0][0], points[0][1], 0, polygon);
-  return centroid;
-}
-function getSegDistSq(px, py, a, b) {
-  let x = a[0];
-  let y = a[1];
-  let dx = b[0] - x;
-  let dy = b[1] - y;
-  if (dx !== 0 || dy !== 0) {
-    const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
-    if (t > 1) {
-      x = b[0];
-      y = b[1];
-    } else if (t > 0) {
-      x += dx * t;
-      y += dy * t;
-    }
-  }
-  dx = px - x;
-  dy = py - y;
-  return dx * dx + dy * dy;
-}
+// src/modify/shared.ts
+var poly = __toESM(require_polylabel(), 1);
 
 // src/modify/consts.ts
 var MajorHighWays = /* @__PURE__ */ new Set([
@@ -91277,7 +91301,7 @@ var MajorHighWays = /* @__PURE__ */ new Set([
 ]);
 
 // src/modify/shared.ts
-var polylabel2 = polylabel;
+var polylabel = poly.default;
 function handleRoadFeature(feature, options, logger) {
   logger.trace({}, "HandleRoadFeature:Start");
   feature = structuredClone(feature);
@@ -91310,6 +91334,11 @@ function handleRoadFeature(feature, options, logger) {
   logger.trace({}, "HandleRoadFeature:End");
   return feature;
 }
+function getInaccessibilityPole(geometry, logger) {
+  const coordinates = getCoordinates(geometry, logger);
+  const inaccessibilityPole = polylabel(coordinates);
+  return { type: "Point", coordinates: inaccessibilityPole };
+}
 function getCoordinates(geometry, logger) {
   switch (geometry.type) {
     case "MultiPolygon":
@@ -91333,10 +91362,7 @@ function handleLayerPois(feature, logger) {
     }
     feature.properties["building"] = bldgUse;
     if (feature.geometry.type === "Polygon" || feature.geometry.type === "MultiPolygon") {
-      const coordinates = getCoordinates(feature.geometry, logger);
-      const inaccessibilityPole = polylabel2(coordinates);
-      const point = { type: "Point", coordinates: inaccessibilityPole };
-      feature.geometry = point;
+      feature.geometry = getInaccessibilityPole(feature.geometry, logger);
     }
   }
   logger.trace({}, "HandlePois:End");
@@ -91358,10 +91384,7 @@ function handleLayerPublicTransport(feature, options, logger) {
 function handleKindAerodrome(feature, logger) {
   logger.trace({}, "HandleKindAerodrome:Start");
   feature = structuredClone(feature);
-  const coordinates = getCoordinates(feature.geometry, logger);
-  const inaccessibilityPole = polylabel2(coordinates);
-  const point = { type: "Point", coordinates: inaccessibilityPole };
-  feature.geometry = point;
+  feature.geometry = getInaccessibilityPole(feature.geometry, logger);
   logger.trace({}, "HandleKindAerodrome:End");
   return feature;
 }
@@ -93211,7 +93234,7 @@ async function upload(file, bucketPath, logger) {
   if (path4.protocol === "file:")
     await (0, import_promises.mkdir)((0, import_path3.dirname)(path4.pathname), { recursive: true });
   if (filename.endsWith("catalog.json"))
-    path4 = new URL(filename, bucketPath);
+    path4 = new URL(`topographic/${filename}`, bucketPath);
   await Fsa.write(path4, stream);
   logger.info({ file, path: path4 }, "Load:Finish");
   return path4;