@foodmarketmaker/mapag 0.0.19 → 0.0.20

package/fesm2022/foodmarketmaker-mapag.mjs

@@ -21,6 +21,7 @@ import maplibregl, { Popup } from 'maplibre-gl';
 import bbox from '@turf/bbox';
 import bboxPolygon from '@turf/bbox-polygon';
 import buffer from '@turf/buffer';
+import difference from '@turf/difference';
 
 function SaveMap(map) {
     var mapCanvas = map.getCanvas();
@@ -35,7 +36,6 @@ function AddLayer(map, layer, afterId) {
         return false;
     try {
         if (map.getLayer(layer.id)) {
-            console.log(`Layer ${layer.id} already exists`);
             return false;
         }
         map.addLayer(layer, afterId);
@@ -14325,99 +14325,43 @@ const mapStyles = {
     },
 };
 
-function isGeoloader(obj) {
-    return typeof obj === 'object' &&
-        obj !== null &&
-        typeof obj.LoadBoundary === 'function';
-}
-function isMultiPolygon(obj) {
-    return typeof obj === 'object' &&
-        obj !== null &&
-        obj.type === 'MultiPolygon';
-}
-function isPolygon(obj) {
-    return typeof obj === 'object' &&
-        obj !== null &&
-        obj.type === 'Polygon';
-}
-function isNumber2DArray(input) {
-    return Array.isArray(input) &&
-        input.every(row => Array.isArray(row) &&
-            row.every(cell => typeof cell === 'number'));
-}
-function isNumber3DArray(input) {
-    return Array.isArray(input) &&
-        input.every(matrix => Array.isArray(matrix) &&
-            matrix.every(row => Array.isArray(row) &&
-                row.every(cell => typeof cell === 'number')));
-}
-function toMultiPolygon(geom) {
-    if (isMultiPolygon(geom)) {
-        return geom;
-    }
-    if (isPolygon(geom)) {
-        return {
-            type: 'MultiPolygon',
-            coordinates: [geom.coordinates]
-        };
-    }
-    if (isNumber2DArray(geom)) {
-        let raw = [geom];
-        const coords = raw;
-        return {
-            type: 'MultiPolygon',
-            coordinates: coords
-        };
-    }
-    let raw = geom;
-    const coords = raw;
-    return {
-        type: 'MultiPolygon',
-        coordinates: coords
-    };
+class BackgroundMaskSettings {
+    fillColor = 'black';
+    fillOpacity = 0.5;
+    visible = true;
+    beforeLayer = StandardLayersMapper.SELECTIONS;
+    zoom = true;
+    mask;
+    loader = undefined;
 }
-
 class BackgroundMaskMapper {
     map;
     count = 0;
     total = 0;
     source = 'mask';
     layer = 'zmask';
-    mask;
-    zoom = true;
-    _fillColor = 'black';
-    _fillOpacity = 0.5;
-    _visible = true;
-    // private _beforeLayer: string | undefined = 'unclustered-search-results'
-    _beforeLayer = StandardLayersMapper.SELECTIONS;
-    set fillColor(color) {
-        this.fillColor = color;
-        this.load();
-    }
-    get fillColor() {
-        return this._fillColor;
-    }
-    set fillOpacity(opacity) {
-        this.fillOpacity = opacity;
-        this.load();
-    }
-    get fillOpacity() {
-        return this._fillOpacity;
-    }
-    set visible(visible) {
-        this._visible = visible;
-        this.load();
+    settings = signal(new BackgroundMaskSettings(), ...(ngDevMode ? [{ debugName: "settings" }] : []));
+    constructor(settings) {
+        if (settings) {
+            this.settings.set({
+                ...this.settings(),
+                ...settings,
+            });
+        }
+        const _ = effect(() => {
+            const settings = this.settings();
+            this._update(settings);
+        }, ...(ngDevMode ? [{ debugName: "_" }] : []));
     }
-    get visible() {
-        return this._visible;
+    update(settings) {
+        this.settings.set({ ...this.settings(), ...settings });
     }
-    set beforeLayer(layerId) {
-        this._beforeLayer = layerId;
+    _update(settings) {
+        if (!this.map) {
+            return;
+        }
         this.load();
     }
-    get beforeLayer() {
-        return this._beforeLayer;
-    }
     onReady(map) {
         this.map = map;
         this.reset();
@@ -14430,11 +14374,12 @@ class BackgroundMaskMapper {
         this.removeLayers();
     }
     flyToBounds() {
-        if (this.map && this.mask) {
+        const settings = this.settings();
+        if (this.map && settings.mask) {
             // minX, minY, maxX, maxY order
-            let bboxCoords = this.mask.bbox;
+            let bboxCoords = settings.mask.bbox;
             if (!bboxCoords) {
-                const f = feature(this.mask);
+                const f = feature(settings.mask);
                 bboxCoords = bbox(f);
             }
             const buffered = buffer(bboxPolygon(bboxCoords), 10, { units: 'miles' });
@@ -14450,17 +14395,36 @@ class BackgroundMaskMapper {
         RemoveLayer(this.map, this.layer);
         RemoveSource(this.map, this.source);
     }
-    load() {
+    async load() {
+        const settings = this.settings();
+        // Check if we need to load from loader first
+        if (!settings.mask && settings.loader) {
+            const geomask = await settings.loader.LoadBoundary();
+            this.update({ mask: geomask, loader: undefined });
+            return;
+        }
         this.removeLayers();
-        if (!this._visible) {
+        if (!settings.visible) {
             return;
         }
-        if (!this.map || !this.mask) {
+        if (!this.map) {
+            return;
+        }
+        if (!settings.mask) {
             return;
         }
-        // Create a simple world polygon without the mask for now
-        // TODO: Implement proper polygon difference
-        const shape = bboxPolygon([-180, -90, 180, 90]);
+        const mask = settings.mask;
+        // Use Turf's difference to cut the mask out of the world polygon
+        const worldPolygon = bboxPolygon([-180, -90, 180, 90]);
+        const features = [worldPolygon];
+        for (const part of mask.coordinates) {
+            features.push(polygon(part));
+        }
+        const fc = {
+            type: 'FeatureCollection',
+            features: features
+        };
+        const shape = difference(fc);
         AddSource(this.map, this.source, {
             type: 'geojson',
             data: shape,
@@ -14470,31 +14434,28 @@ class BackgroundMaskMapper {
             source: this.source,
             type: 'fill',
             paint: {
-                'fill-color': this.fillColor,
-                'fill-opacity': this.fillOpacity,
+                'fill-color': settings.fillColor,
+                'fill-opacity': settings.fillOpacity,
             },
-        }, this.beforeLayer);
-        if (this.zoom) {
+        }, settings.beforeLayer);
+        if (settings.zoom) {
             this.flyToBounds();
         }
     }
-    async setMask(mask, show = true) {
-        if (isGeoloader(mask)) {
-            this.mask = await mask.LoadBoundary();
-        }
-        else {
-            this.mask = toMultiPolygon(mask);
-        }
-        if (!show) {
-            return;
-        }
-        this.visible = true;
-    }
-    async loadGeoJsonFromLoader(loader) {
-        // Load the boundary from the external loader
-        const geomask = await loader.LoadBoundary();
-        this.mask = geomask;
-        this.load();
+    // async setMask(mask: Geoloader | MultiPolygon | Polygon | number[][] | number[][][], show: boolean = true) {
+    //   if (isGeoloader(mask)) {
+    //     this.update({ mask: await mask.LoadBoundary() });
+    //   } else {
+    //     this.update({ mask: toMultiPolygon(mask) });
+    //   }
+    // }
+    // async loadGeoJsonFromLoader(loader: Geoloader) {
+    //   // Load the boundary from the external loader
+    //   const geomask = await loader.LoadBoundary();
+    //   this.update({ mask: geomask });
+    // }
+    getSettings() {
+        return { ...this.settings() };
     }
 }
 
@@ -15404,6 +15365,7 @@ class HardinessMapper {
         }
         else {
             this.map.setLayoutProperty(this.LAYER_ID, 'visibility', 'none');
+            return;
         }
         // Update paint properties
         this.map.setPaintProperty(this.LAYER_ID, 'fill-color', [
@@ -15611,6 +15573,334 @@ class NAASSettings {
     autoSelectLayer = false;
 }
 
+class NaicsMapperSettings {
+    type = 'circle';
+    visible = true;
+    radius = 8;
+    color = '#1f77b4';
+    opacity = 0.8;
+    strokeWidth = 1;
+    strokeColor = '#ffffff';
+    iconUrl = '';
+    iconName = 'naics-icon';
+    iconSize = 0.8;
+    iconAllowOverlap = true;
+    iconSdf = false;
+}
+class NaicsMapper {
+    legends = [];
+    count = 0;
+    total = 0;
+    map;
+    svc;
+    id;
+    name;
+    static pmtilesUrl = 'https://foodmarketmaker-upload-data.s3.amazonaws.com/tiles/secondary_101124.pmtiles';
+    static sourceLayer = 'secondary_101124';
+    SOURCE_ID = 'naics-pmtiles';
+    sourceLayer = NaicsMapper.sourceLayer;
+    CIRCLE_LAYER_ID;
+    ICON_LAYER_ID;
+    HEATMAP_LAYER_ID;
+    currentFilter;
+    settings = signal(new NaicsMapperSettings(), ...(ngDevMode ? [{ debugName: "settings" }] : []));
+    constructor(settings, id = 'naics-' + Math.random().toString(36)) {
+        this.id = id;
+        this.name = `NAICS Mapper (${id})`;
+        // Make layer IDs unique per instance
+        this.CIRCLE_LAYER_ID = `${id}-circles`;
+        this.ICON_LAYER_ID = `${id}-icons`;
+        this.HEATMAP_LAYER_ID = `${id}-heatmap`;
+        if (settings) {
+            this.settings.set({
+                ...this.settings(),
+                ...settings,
+            });
+        }
+        const _ = effect(() => {
+            const settings = this.settings();
+            this._update(settings);
+        }, ...(ngDevMode ? [{ debugName: "_" }] : []));
+    }
+    update(settings) {
+        this.settings.set({ ...this.settings(), ...settings });
+    }
+    async _update(settings) {
+        if (!this.map) {
+            return;
+        }
+        const map = this.map;
+        this.create();
+        // Update paint/layout properties based on type
+        switch (settings.type) {
+            case 'circle':
+                if (map.getLayer(this.CIRCLE_LAYER_ID)) {
+                    map.setLayoutProperty(this.CIRCLE_LAYER_ID, 'visibility', settings.visible ? 'visible' : 'none');
+                    map.setPaintProperty(this.CIRCLE_LAYER_ID, 'circle-radius', settings.radius);
+                    map.setPaintProperty(this.CIRCLE_LAYER_ID, 'circle-color', settings.color);
+                    map.setPaintProperty(this.CIRCLE_LAYER_ID, 'circle-opacity', settings.opacity);
+                    map.setPaintProperty(this.CIRCLE_LAYER_ID, 'circle-stroke-width', settings.strokeWidth);
+                    map.setPaintProperty(this.CIRCLE_LAYER_ID, 'circle-stroke-color', settings.strokeColor);
+                }
+                break;
+            case 'icon':
+                if (map.getLayer(this.ICON_LAYER_ID)) {
+                    await this.loadIcon();
+                    map.setLayoutProperty(this.ICON_LAYER_ID, 'visibility', settings.visible ? 'visible' : 'none');
+                    map.setLayoutProperty(this.ICON_LAYER_ID, 'icon-image', settings.iconName);
+                    map.setLayoutProperty(this.ICON_LAYER_ID, 'icon-size', settings.iconSize);
+                    map.setPaintProperty(this.ICON_LAYER_ID, 'icon-color', settings.color);
+                    map.setLayoutProperty(this.ICON_LAYER_ID, 'icon-allow-overlap', settings.iconAllowOverlap);
+                }
+                break;
+            case 'heatmap':
+                if (map.getLayer(this.HEATMAP_LAYER_ID)) {
+                    map.setLayoutProperty(this.HEATMAP_LAYER_ID, 'visibility', settings.visible ? 'visible' : 'none');
+                    map.setPaintProperty(this.HEATMAP_LAYER_ID, 'heatmap-radius', settings.radius);
+                    map.setPaintProperty(this.HEATMAP_LAYER_ID, 'heatmap-opacity', settings.opacity);
+                }
+                break;
+        }
+    }
+    onReady(map, svc) {
+        this.map = map;
+        this.svc = svc;
+        this.create();
+    }
+    reset() {
+        this.count = 0;
+        this.total = 0;
+        this.legends = [];
+        this.currentFilter = undefined;
+    }
+    clear() {
+        if (!this.map) {
+            return;
+        }
+        // Remove all layers for this instance
+        RemoveLayer(this.map, this.CIRCLE_LAYER_ID);
+        RemoveLayer(this.map, this.ICON_LAYER_ID);
+        RemoveLayer(this.map, this.HEATMAP_LAYER_ID);
+        this.map.off('click', this.CIRCLE_LAYER_ID, this.onClick);
+        this.map.off('click', this.ICON_LAYER_ID, this.onClick);
+        this.map.off('touchend', this.CIRCLE_LAYER_ID, this.onClick);
+        this.map.off('touchend', this.ICON_LAYER_ID, this.onClick);
+        this.count = 0;
+        this.currentFilter = undefined;
+    }
+    updateLegends() { }
+    // Method to create PMTiles layers
+    create() {
+        if (!this.map) {
+            return;
+        }
+        const map = this.map;
+        const settings = this.settings();
+        // Add PMTiles source only if it doesn't exist (shared across instances)
+        AddSource(map, this.SOURCE_ID, {
+            type: 'vector',
+            url: `pmtiles://${NaicsMapper.pmtilesUrl}`,
+        });
+        // Add visualization layer based on type
+        this.addVisualizationLayer(map);
+        // Add cluster layers if clustering is enabled
+        // this.addClusterLayers(map);
+        // Add popup on click
+        map.on('click', this.CIRCLE_LAYER_ID, this.onClick);
+        map.on('click', this.ICON_LAYER_ID, this.onClick);
+        map.on('touchend', this.CIRCLE_LAYER_ID, this.onClick);
+        map.on('touchend', this.ICON_LAYER_ID, this.onClick);
+    }
+    getActiveLayerId() {
+        const settings = this.settings();
+        switch (settings.type) {
+            case 'circle':
+                return this.CIRCLE_LAYER_ID;
+            case 'icon':
+                return this.ICON_LAYER_ID;
+            case 'heatmap':
+                return this.HEATMAP_LAYER_ID;
+            default:
+                return this.CIRCLE_LAYER_ID;
+        }
+    }
+    async loadIcon() {
+        if (!this.map) {
+            return;
+        }
+        const map = this.map;
+        const settings = this.settings();
+        if (settings.iconUrl && !map.hasImage(settings.iconName)) {
+            await mapboxloadImage(map, {
+                name: settings.iconName,
+                url: settings.iconUrl,
+                sdf: settings.iconSdf,
+            });
+        }
+    }
+    async addVisualizationLayer(map) {
+        const settings = this.settings();
+        // Remove existing layers that ar not needed
+        if (settings.type !== 'circle')
+            RemoveLayer(map, this.CIRCLE_LAYER_ID);
+        if (settings.type !== 'icon')
+            RemoveLayer(map, this.ICON_LAYER_ID);
+        if (settings.type !== 'heatmap')
+            RemoveLayer(map, this.HEATMAP_LAYER_ID);
+        // Add layer based on type
+        switch (settings.type) {
+            case 'circle':
+                AddLayer(map, {
+                    id: this.CIRCLE_LAYER_ID,
+                    type: 'circle',
+                    source: this.SOURCE_ID,
+                    'source-layer': this.sourceLayer,
+                    layout: {
+                        visibility: settings.visible ? 'visible' : 'none',
+                    },
+                    paint: {
+                        'circle-radius': settings.radius,
+                        'circle-color': settings.color,
+                        'circle-opacity': settings.opacity,
+                        'circle-stroke-width': settings.strokeWidth,
+                        'circle-stroke-color': settings.strokeColor,
+                    },
+                }, StandardLayersMapper.POINTS);
+                break;
+            case 'icon':
+                // Load icon image if URL is provided and not already loaded
+                await this.loadIcon();
+                AddLayer(map, {
+                    id: this.ICON_LAYER_ID,
+                    type: 'symbol',
+                    source: this.SOURCE_ID,
+                    'source-layer': this.sourceLayer,
+                    layout: {
+                        visibility: settings.visible ? 'visible' : 'none',
+                        'icon-image': settings.iconName,
+                        'icon-size': settings.iconSize,
+                        'icon-allow-overlap': settings.iconAllowOverlap,
+                    },
+                    paint: {
+                        // Additional paint properties can be added here if needed
+                        'icon-color': settings.color,
+                    }
+                }, StandardLayersMapper.POINTS);
+                break;
+            case 'heatmap':
+                AddLayer(map, {
+                    id: this.HEATMAP_LAYER_ID,
+                    type: 'heatmap',
+                    source: this.SOURCE_ID,
+                    'source-layer': this.sourceLayer,
+                    layout: {
+                        visibility: settings.visible ? 'visible' : 'none',
+                    },
+                    paint: {
+                        'heatmap-weight': 1,
+                        'heatmap-intensity': 1,
+                        'heatmap-color': [
+                            'interpolate',
+                            ['linear'],
+                            ['heatmap-density'],
+                            0, 'rgba(0, 0, 255, 0)',
+                            0.1, 'royalblue',
+                            0.3, 'cyan',
+                            0.5, 'lime',
+                            0.7, 'yellow',
+                            1, 'red',
+                        ],
+                        'heatmap-radius': settings.radius,
+                        'heatmap-opacity': settings.opacity,
+                    },
+                }, StandardLayersMapper.POLYGONS_ACTIVE);
+                break;
+        }
+        // Reapply filter if exists
+        if (this.currentFilter) {
+            this.filterByNaicsCode(map, this.currentFilter);
+        }
+    }
+    // Method to filter by NAICS code (startsWith match)
+    filterByNaicsCode(map, naicsCode) {
+        this.currentFilter = naicsCode;
+        const filter = naicsCode ? ['==', ['slice', ['get', 'NAICS_CODE'], 0, naicsCode.length], naicsCode] : null;
+        const layerId = this.getActiveLayerId();
+        if (map.getLayer(layerId)) {
+            map.setFilter(layerId, filter);
+        }
+    }
+    // Get current settings
+    getSettings() {
+        return { ...this.settings() };
+    }
+    onClick = (e) => {
+        if (!this.map) {
+            return;
+        }
+        const map = this.map;
+        let features;
+        const settings = this.settings();
+        if (settings.type == 'circle') {
+            features = this.map.queryRenderedFeatures(e.point, {
+                layers: [this.CIRCLE_LAYER_ID],
+            });
+        }
+        else if (settings.type == 'icon') {
+            features = this.map.queryRenderedFeatures(e.point, {
+                layers: [this.ICON_LAYER_ID],
+            });
+        }
+        if (!features || features.length == 0) {
+            return;
+        }
+        if (features.length > 0) {
+            const item = features[0];
+            if (item) {
+                this.renderPopup(item).then((html) => {
+                    if (!html) {
+                        return;
+                    }
+                    new Popup().setLngLat(e.lngLat).setHTML(html).addTo(map);
+                });
+            }
+        }
+    };
+    async renderPopup(f) {
+        if (!f || !f.properties) {
+            return undefined;
+        }
+        const item = f.properties;
+        let html = `<b>${item['COMPANY_NAME'] || 'MISSING NAME'}</b><br>`;
+        if (item?.['WEB_ADDRESS']) {
+            let url = item['WEB_ADDRESS'].startsWith('http') ? item['WEB_ADDRESS'] : 'https://' + item['WEB_ADDRESS'];
+            html += `<a href='${url}' target='_blank'>${url}</a><br />`;
+        }
+        if (item?.['ADDRESS']) {
+            html += `${item?.['ADDRESS']}<br />`;
+        }
+        if (item?.['CITY'] && item?.['STATE']) {
+            html += `${item?.['CITY']}, ${item?.['STATE']}<br />`;
+        }
+        if (item?.['PHONE']) {
+            html += `${item?.['PHONE']}<br /><br />`;
+        }
+        if (item?.['SALES_VOLUME']) {
+            html += `<b>Sales: </b>${item?.['SALES_VOLUME']}<br />`;
+        }
+        if (item?.['NUMBER_OF_EMPLOYEES']) {
+            html += `<b>Employees: </b>${item?.['NUMBER_OF_EMPLOYEES']}<br />`;
+        }
+        if (item?.['NAICS_CODE']) {
+            html += `<b>NAICS: </b>${item?.['NAICS_CODE']} ${item?.['NAICS_DESCRIPTION']} <br />`;
+        }
+        if (item?.['SIC_CODE1']) {
+            html += `<b>SIC: </b>${item?.['SIC_CODE1']} ${item?.['SIC1_DESCRIPTION']}`;
+        }
+        return html;
+    }
+}
+
 class SimpleMapper {
     reset() {
         if (this.map) {
@@ -15992,6 +16282,58 @@ class WatershedSettings {
     autoSelectLayer = false;
 }
 
+function isGeoloader(obj) {
+    return typeof obj === 'object' &&
+        obj !== null &&
+        typeof obj.LoadBoundary === 'function';
+}
+function isMultiPolygon(obj) {
+    return typeof obj === 'object' &&
+        obj !== null &&
+        obj.type === 'MultiPolygon';
+}
+function isPolygon(obj) {
+    return typeof obj === 'object' &&
+        obj !== null &&
+        obj.type === 'Polygon';
+}
+function isNumber2DArray(input) {
+    return Array.isArray(input) &&
+        input.every(row => Array.isArray(row) &&
+            row.every(cell => typeof cell === 'number'));
+}
+function isNumber3DArray(input) {
+    return Array.isArray(input) &&
+        input.every(matrix => Array.isArray(matrix) &&
+            matrix.every(row => Array.isArray(row) &&
+                row.every(cell => typeof cell === 'number')));
+}
+function toMultiPolygon(geom) {
+    if (isMultiPolygon(geom)) {
+        return geom;
+    }
+    if (isPolygon(geom)) {
+        return {
+            type: 'MultiPolygon',
+            coordinates: [geom.coordinates]
+        };
+    }
+    if (isNumber2DArray(geom)) {
+        let raw = [geom];
+        const coords = raw;
+        return {
+            type: 'MultiPolygon',
+            coordinates: coords
+        };
+    }
+    let raw = geom;
+    const coords = raw;
+    return {
+        type: 'MultiPolygon',
+        coordinates: coords
+    };
+}
+
 class HttpBoundaryLoader {
     static NewCustom(http, path) {
         const loader = new HttpBoundaryLoader(http);
@@ -16096,5 +16438,5 @@ class HttpBoundaryLoader {
  * Generated bundle index. Do not edit.
  */
 
-export { AddLayer, AddSource, AreaMapperMapper, BackgroundMaskMapper, BaseMapLight, BasemapSelect, BasemapSelectMenu, CensusTractMapper, CroplandDataLayerMapper, CroplandDataLayerSettings, CroplandLegend, DEFAULT_GLYPHS, DrawingMapper, EsriMapper, EsriSettings, HardinessMapper, HardinessSettings, HttpBoundaryLoader, MapAreaSelectComponent, MapComponent, MapSelectionService, MapService, MapStyles, MapboxMapperGroup, NAASMapper, NAASSettings, NoOpMapper, RemoveLayer, RemoveSource, SaveMap, SelectMode, SimpleMapper, StandardLayersMapper, Styles, VectorTileServerMapper, WatershedMapper, WatershedSettings, discoverLayers, isGeoloader, isMultiPolygon, isNumber2DArray, isNumber3DArray, isPolygon, mapboxLoadImages, mapboxloadImage, pmtilesPixelInfo, sampleTilesForLayers, simpleClone, toMultiPolygon, trySync };
+export { AddLayer, AddSource, AreaMapperMapper, BackgroundMaskMapper, BackgroundMaskSettings, BaseMapLight, BasemapSelect, BasemapSelectMenu, CensusTractMapper, CroplandDataLayerMapper, CroplandDataLayerSettings, CroplandLegend, DEFAULT_GLYPHS, DrawingMapper, EsriMapper, EsriSettings, HardinessMapper, HardinessSettings, HttpBoundaryLoader, MapAreaSelectComponent, MapComponent, MapSelectionService, MapService, MapStyles, MapboxMapperGroup, NAASMapper, NAASSettings, NaicsMapper, NaicsMapperSettings, NoOpMapper, RemoveLayer, RemoveSource, SaveMap, SelectMode, SimpleMapper, StandardLayersMapper, Styles, VectorTileServerMapper, WatershedMapper, WatershedSettings, discoverLayers, isGeoloader, isMultiPolygon, isNumber2DArray, isNumber3DArray, isPolygon, mapboxLoadImages, mapboxloadImage, pmtilesPixelInfo, sampleTilesForLayers, simpleClone, toMultiPolygon, trySync };
 //# sourceMappingURL=foodmarketmaker-mapag.mjs.map