@massif-maps/web 6.1.0-rc.1

package/massif-maps.bundle.mjs

@@ -0,0 +1,2459 @@
+// ../../bindings/js/dist/observable.js
+var Observable = class {
+  constructor() {
+    this.mListeners = {};
+  }
+  on(eventNames2, callback, thisArg) {
+    this.addEventListener(eventNames2, callback, thisArg);
+  }
+  once(eventNames2, callback, thisArg) {
+    this.addEventListener(eventNames2, callback, thisArg, true);
+  }
+  off(eventNames2, callback, thisArg) {
+    this.removeEventListener(eventNames2, callback, thisArg);
+  }
+  /** `eventNames` may list several, comma-separated, as NativeScript's does. */
+  addEventListener(eventNames2, callback, thisArg, once = false) {
+    var _a;
+    for (const name of names(eventNames2)) {
+      ((_a = this.mListeners)[name] ?? (_a[name] = [])).push({ callback, thisArg, once });
+    }
+  }
+  removeEventListener(eventNames2, callback, thisArg) {
+    for (const name of names(eventNames2)) {
+      const kept = (this.mListeners[name] ?? []).filter((l) => callback && (l.callback !== callback || thisArg !== void 0 && l.thisArg !== thisArg));
+      if (kept.length) {
+        this.mListeners[name] = kept;
+      } else {
+        delete this.mListeners[name];
+      }
+    }
+  }
+  hasListeners(eventName) {
+    return !!this.mListeners[eventName]?.length;
+  }
+  notify(data) {
+    const listeners = this.mListeners[data.eventName];
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners.slice()) {
+      if (listener.once) {
+        this.removeEventListener(data.eventName, listener.callback, listener.thisArg);
+      }
+      listener.callback.call(listener.thisArg, data);
+    }
+  }
+};
+function names(eventNames2) {
+  return eventNames2.split(",").map((name) => name.trim()).filter(Boolean);
+}
+
+// ../../bindings/js/dist/bridge.js
+var UNAVAILABLE = { available: false, canConsume: false };
+var bridge = UNAVAILABLE;
+function setBridge(platform) {
+  bridge = platform;
+}
+
+// ../../bindings/js/dist/schema.js
+var PROPS = {
+  "massif::Address": "categories,t;country,s;county,s;houseNumber,s;locality,s;name,s;neighbourhood,s;postcode,s;region,s;street,s",
+  "massif::AnimationStyle": "fadeAnimationType,e,AnimationType;phaseInDuration,f;phaseOutDuration,f;relativeSpeed,f;sizeAnimationType,e,AnimationType",
+  "massif::AnimationStyleBuilder": "fadeAnimationType,e,AnimationType;phaseInDuration,f;phaseOutDuration,f;relativeSpeed,f;sizeAnimationType,e,AnimationType",
+  "massif::AssetPackage": "assetNames,t",
+  "massif::BalloonPopup": "balloonPopupEventListener,o,massif::BalloonPopupEventListener;description,s;style,o,massif::BalloonPopupStyle;title,s",
+  "massif::BalloonPopupButton": "style,o,massif::BalloonPopupButtonStyle;tag,v;text,s",
+  "massif::BalloonPopupButtonClickInfo": "button,o,massif::BalloonPopupButton;clickInfo,t;clickType,e,ClickType;vectorElement,o,massif::VectorElement",
+  "massif::BalloonPopupButtonStyle": "backgroundColor,c;buttonWidth,i;cornerRadius,i;strokeColor,c;strokeWidth,i;textColor,c;textFontName,s;textFontSize,i;textMargins,t",
+  "massif::BalloonPopupButtonStyleBuilder": "buttonWidth,i;cornerRadius,i;strokeColor,c;strokeWidth,i;textColor,c;textFontName,s;textFontSize,i;textMargins,t",
+  "massif::BalloonPopupMargins": "bottom,i;left,i;right,i;top,i",
+  "massif::BalloonPopupStyle": "backgroundColor,c;buttonMargins,t;cornerRadius,i;descriptionColor,c;descriptionField,s;descriptionFontName,s;descriptionFontSize,i;descriptionMargins,t;descriptionWrap,b;leftColor,c;leftImage,o,massif::Bitmap;leftMargins,t;rightColor,c;rightImage,o,massif::Bitmap;rightMargins,t;strokeColor,c;strokeWidth,i;titleColor,c;titleField,s;titleFontName,s;titleFontSize,i;titleMargins,t;titleWrap,b;triangleHeight,i;triangleWidth,i",
+  "massif::BalloonPopupStyleBuilder": "buttonMargins,t;cornerRadius,i;descriptionColor,c;descriptionField,s;descriptionFontName,s;descriptionFontSize,i;descriptionMargins,t;descriptionWrap,b;leftColor,c;leftImage,o,massif::Bitmap;leftMargins,t;rightColor,c;rightImage,o,massif::Bitmap;rightMargins,t;strokeColor,c;strokeWidth,i;titleColor,c;titleField,s;titleFontName,s;titleFontSize,i;titleMargins,t;titleWrap,b;triangleHeight,i;triangleWidth,i",
+  "massif::BaseMapView": "cameraPos,p;flightActive,b;flightProgress,f;focusPos,p;mapRenderer,o,massif::MapRenderer;rotation,f;tilt,f;zoom,f",
+  "massif::Billboard": "baseBillboard,o,massif::Billboard;bounds,p;geometry,o,massif::Geometry;rootGeometry,o,massif::Geometry;rotation,f",
+  "massif::BillboardStyle": "animationStyle,o,massif::AnimationStyle;attachAnchorPointX,f;attachAnchorPointY,f;causesOverlap,b;hideIfOverlapped,b;horizontalOffset,f;placementPriority,i;scaleWithDPI,b;verticalOffset,f",
+  "massif::BillboardStyleBuilder": "animationStyle,o,massif::AnimationStyle;attachAnchorPointX,f;attachAnchorPointY,f;causesOverlap,b;hideIfOverlapped,b;horizontalOffset,f;placementPriority,i;scaleWithDPI,b;verticalOffset,f",
+  "massif::BinaryData": "size,i",
+  "massif::Bitmap": "bytesPerPixel,i;colorFormat,e,ColorFormat;height,i;width,i",
+  "massif::BundleAssetPackage": "basePath,s;localAssetNames,t",
+  "massif::CacheTileDataSource": "capacity,i;dataSource,o,massif::TileDataSource",
+  "massif::CartoCSSStyleSet": "assetPackage,o,massif::AssetPackage;cartoCSS,s",
+  "massif::CelestialArc": "belowHorizonVisible,b;clickRadius,f;radius,f;segmented,b;width,f",
+  "massif::CelestialClickInfo": "altitude,f;azimuth,f;celestialObject,o,massif::CelestialObject;clickInfo,t;clickType,e,ClickType",
+  "massif::CelestialImage": "bitmap,o,massif::Bitmap;luminanceAlpha,b",
+  "massif::CelestialLabel": "anchorPointX,f;anchorPointY,f;backgroundColor,c;backgroundRadius,f;clickable,b;fontName,s;fontSize,f;haloColor,c;haloWidth,f;offsetX,f;offsetY,f;paddingX,f;paddingY,f;text,s;textColor,c",
+  "massif::CelestialLayer": "celestialEventListener,o,massif::CelestialEventListener",
+  "massif::CelestialObject": "altitude,f;azimuth,f;color,c;directionAnchored,b;distance,f;metaData,g,v;occludedByMap,b;position,p;positionAltitude,f;visible,b",
+  "massif::CelestialSprite": "angularSize,f;bitmap,o,massif::Bitmap;clickRadius,f;screenSize,f;softness,f",
+  "massif::ClickInfo": "clickType,e,ClickType;duration,f",
+  "massif::ClusteredVectorLayer": "animatedClusters,b;clusterElementBuilder,o,massif::ClusterElementBuilder;maximumClusterZoom,f;minimumClusterDistance,f",
+  "massif::Color": "ARGB,i;a,i;b,i;g,i;r,i",
+  "massif::CompiledStyleSet": "assetPackage,o,massif::AssetPackage;styleAssetName,s;styleName,s",
+  "massif::ContourTileDataSource": "baseInterval,f;labelInterval,f;labelStubsEnabled,b;layerName,s;minVisibleZoom,i;resolution,i;seamlessEdgesEnabled,b;simplifyTolerance,f;terrainOptions,o,massif::TerrainOptions",
+  "massif::CullState": "viewState,t",
+  "massif::CustomPopup": "popupHandler,o,massif::CustomPopupHandler",
+  "massif::CustomRasterTileLayer": "shaderSource,s",
+  "massif::DirAssetPackage": "dirPath,s;localAssetNames,t",
+  "massif::EditableVectorLayer": "selectedVectorElement,o,massif::VectorElement;vectorEditEventListener,o,massif::VectorEditEventListener",
+  "massif::Feature": "geometry,o,massif::Geometry;geometryGeoJSON,s;properties,v",
+  "massif::FeatureBuilder": "geometry,o,massif::Geometry",
+  "massif::FeatureCollection": "featureCount,i",
+  "massif::FeatureCollectionSearchService": "featureCollection,o,massif::FeatureCollection;maxResults,i;projection,o,massif::Projection",
+  "massif::FogOptions": "color,c;enabled,b;highColor,c;horizonBlend,f;rangeEnd,f;rangeStart,f;shaderSource,s;spaceColor,c;starIntensity,f;verticalRangeEnd,f;verticalRangeStart,f",
+  "massif::GeoJSONGeometryReader": "targetProjection,o,massif::Projection",
+  "massif::GeoJSONGeometryWriter": "sourceProjection,o,massif::Projection;z,b",
+  "massif::GeoJSONVectorTileDataSource": "defaultLayerBuffer,f;simplifyTolerance,f",
+  "massif::GeocodingRequest": "location,p;locationRadius,f;projection,o,massif::Projection;query,s",
+  "massif::GeocodingResult": "address,t;featureCollection,o,massif::FeatureCollection;projection,o,massif::Projection;rank,f",
+  "massif::GeocodingService": "autocomplete,b;language,s;maxResults,i",
+  "massif::Geometry": "bounds,p;centerPos,p;geoJSON,s;type,e,GeometryType",
+  "massif::GeometryCollection": "geometry,o,massif::MultiGeometry;style,o,massif::GeometryCollectionStyle",
+  "massif::GeometryCollectionStyle": "lineStyle,o,massif::LineStyle;pointStyle,o,massif::PointStyle;polygonStyle,o,massif::PolygonStyle",
+  "massif::GeometryCollectionStyleBuilder": "lineStyle,o,massif::LineStyle;pointStyle,o,massif::PointStyle;polygonStyle,o,massif::PolygonStyle",
+  "massif::HTTPTileDataSource": "HTTPHeaders,g,s;TMSScheme,b;baseURL,s;maxAgeHeaderCheck,b;subdomains,t;timeout,i",
+  "massif::HillshadeRasterTileLayer": "accentColor,c;contourColor,c;contourEnabled,b;contourInterval,f;contourWidth,f;contrast,f;elevationEncodingEnabled,b;exagerateHeightScaleEnabled,b;exaggeration,f;heightScale,f;highlightColor,c;hillshadeMethod,e,HillshadeMethod;illuminationDirection,t;illuminationMapRotationEnabled,b;legacyHeightScaleEnabled,b;normalMapLightingShader,s;shadowColor,c;terrainPaintEnabled,b;terrainPaintFullDetailEnabled,b",
+  "massif::Label": "style,o,massif::LabelStyle",
+  "massif::LabelStyle": "anchorPointX,f;anchorPointY,f;flippable,b;orientationMode,e,BillboardOrientation;renderScale,f;scalingMode,e,BillboardScaling",
+  "massif::LabelStyleBuilder": "anchorPointX,f;anchorPointY,f;flippable,b;orientationMode,e,BillboardOrientation;renderScale,f;scalingMode,e,BillboardScaling",
+  "massif::Layer": "cullDelay,i;metaData,g,v;opacity,f;postProcessed,b;updatePriority,i;visible,b;visibleZoomRange,t",
+  "massif::Layers": "count,i",
+  "massif::LightOptions": "ambientColor,c;ambientIntensity,f;dayCycleLightStops,t;dayCycleLightsEnabled,b;dayCycleRisingLightStops,t;shadowBias,f;shadowCascades,i;shadowCasterMargin,i;shadowDistance,f;shadowMapSize,i;shadowNormalOffset,f;shadowSoftness,f;shadowStrength,f;sunAltitude,f;sunAzimuth,f;sunColor,c;sunIntensity,f;sunOverridingStyle,b;terrainLightingEnabled,b",
+  "massif::LightStop": "ambientColor,c;ambientIntensity,f;sunAltitude,f;sunColor,c;sunIntensity,f",
+  "massif::Line": "geometry,o,massif::LineGeometry;style,o,massif::LineStyle",
+  "massif::LineGeometry": "poses,t",
+  "massif::LineStyle": "bitmap,o,massif::Bitmap;clickWidth,f;lineEndType,e,LineEndType;lineJoinType,e,LineJoinType;stretchFactor,f;width,f",
+  "massif::LineStyleBuilder": "bitmap,o,massif::Bitmap;clickWidth,f;lineEndType,e,LineEndType;lineJoinType,e,LineJoinType;stretchFactor,f;width,f",
+  "massif::LocalVectorDataSource": "geometrySimplifier,o,massif::GeometrySimplifier",
+  "massif::Log": "logEventListener,o,massif::LogEventListener;showDebug,b;showError,b;showInfo,b;showWarn,b;tag,s",
+  "massif::MBVectorTileDecoder": "cartoCSSStyle,o,massif::CartoCSSStyleSet;compiledStyle,o,massif::CompiledStyleSet;featureIdOverride,b;params,g,s;styleLayerNames,t;styleParameters,t;tileFormat,e,TileFormat",
+  "massif::ManeuverArrowBuilder": "lengthAfter,f;lengthBefore,f",
+  "massif::MapBounds": "center,p;delta,t;max,p;min,p",
+  "massif::MapBoxOnlineGeocodingService": "customServiceURL,s",
+  "massif::MapBoxOnlineReverseGeocodingService": "customServiceURL,s",
+  "massif::MapClickInfo": "clickInfo,t;clickPos,p;clickType,e,ClickType",
+  "massif::MapEnvelope": "bounds,p;convexHull,t",
+  "massif::MapInteractionInfo": "animationStarted,b;panAction,b;rotateAction,b;tiltAction,b;zoomAction,b",
+  "massif::MapMoveInfo": "reason,e,MapMoveReason",
+  "massif::MapPos": "x,f;y,f;z,f",
+  "massif::MapRange": "length,f;max,f;midrange,f;min,f",
+  "massif::MapRenderer": "mapRendererListener,o,massif::MapRendererListener;postProcessEffect,o,massif::PostProcessEffect",
+  "massif::MapTile": "frameNr,i;tileId,i;x,i;y,i;zoom,i",
+  "massif::MapTilerOnlineTileDataSource": "customServiceURL,s;timeout,i",
+  "massif::MapVec": "length,f;normalized,t;x,f;y,f;z,f",
+  "massif::Marker": "style,o,massif::MarkerStyle",
+  "massif::MarkerStyle": "anchorPointX,f;anchorPointY,f;bitmap,o,massif::Bitmap;clickSize,f;orientationMode,e,BillboardOrientation;scalingMode,e,BillboardScaling;size,f",
+  "massif::MarkerStyleBuilder": "anchorPointX,f;anchorPointY,f;bitmap,o,massif::Bitmap;clickSize,f;orientationMode,e,BillboardOrientation;scalingMode,e,BillboardScaling;size,f",
+  "massif::MultiGeometry": "geometryCount,i",
+  "massif::NMLModel": "rotationAngle,f;rotationAxis,t;scale,f;style,o,massif::NMLModelStyle",
+  "massif::NMLModelStyle": "modelAsset,o,massif::BinaryData;orientationMode,e,BillboardOrientation;scalingMode,e,BillboardScaling",
+  "massif::NMLModelStyleBuilder": "modelAsset,o,massif::BinaryData;orientationMode,e,BillboardOrientation;scalingMode,e,BillboardScaling",
+  "massif::Options": "DPI,f;ambientLightColor,c;backgroundBitmap,o,massif::Bitmap;baseProjection,o,massif::Projection;clearColor,c;clickMovingTolerance,f;clickTypeDetection,b;debugTileBorders,b;doubleClickDetection,b;doubleClickMaxDuration,f;drawDistance,f;envelopeThreadPoolSize,i;fieldOfViewY,f;focusPointOffset,t;fogOptions,o,massif::FogOptions;freeRoamLookSensitivity,f;freeRoamMode,e,FreeRoamMode;freeRoamMoveSpeed,f;kineticPan,b;kineticRotation,b;kineticZoom,b;labelPadding,f;labelViewDistance,f;layersLabelsProcessedInReverseOrder,b;lightOptions,o,massif::LightOptions;longClickDuration,f;mainLightColor,c;mainLightDirection,t;panBounds,p;panningMode,e,PanningMode;panningSpeedMode,e,PanningSpeedMode;pivotMode,e,PivotMode;renderProjectionMode,e,RenderProjectionMode;restrictedPanning,b;rotatable,b;rotationGestures,b;seamlessPanning,b;skyColor,c;skyOptions,o,massif::SkyOptions;terrainOptions,o,massif::TerrainOptions;tileDrawSize,i;tileLODFactor,f;tileLODMaxZoomLevelsOnScreen,f;tileLODTileCountRatio,f;tileStyleZoomLift,i;tileThreadPoolSize,i;tiltGestureReversed,b;tiltRange,t;userInput,b;zoomGestures,b;zoomOffset,f;zoomRange,t",
+  "massif::PackageInfo": "metaInfo,o,massif::PackageMetaInfo;name,s;packageId,s;packageType,e,PackageType;size,i;tileMask,o,massif::PackageTileMask;version,i",
+  "massif::PackageManager": "localPackages,t;packageManagerListener,o,massif::PackageManagerListener;serverPackageListAge,i;serverPackageListMetaInfo,o,massif::PackageMetaInfo;serverPackages,t",
+  "massif::PackageManagerTileDataSource": "packageManager,o,massif::PackageManager",
+  "massif::PackageMetaInfo": "variant,v",
+  "massif::PackageStatus": "currentAction,e,PackageAction;paused,b;progress,f",
+  "massif::PackageTileMask": "maxZoomLevel,i;stringValue,s",
+  "massif::PeliasOnlineGeocodingService": "customServiceURL,s",
+  "massif::PeliasOnlineReverseGeocodingService": "customServiceURL,s",
+  "massif::PersistentCacheTileDataSource": "cacheOnlyMode,b;open,b",
+  "massif::Point": "geometry,o,massif::PointGeometry;style,o,massif::PointStyle",
+  "massif::PointDetailTileDataSource": "detailZoom,i;layerName,s;maxDetailLevels,i;maxFeatures,i;rankProperty,s",
+  "massif::PointGeometry": "pos,p",
+  "massif::PointStyle": "bitmap,o,massif::Bitmap;clickSize,f;size,f",
+  "massif::PointStyleBuilder": "bitmap,o,massif::Bitmap;clickSize,f;size,f",
+  "massif::Polygon": "geometry,o,massif::PolygonGeometry;style,o,massif::PolygonStyle",
+  "massif::Polygon3D": "geometry,o,massif::PolygonGeometry;height,f;style,o,massif::Polygon3DStyle",
+  "massif::Polygon3DStyle": "sideColor,c",
+  "massif::Polygon3DStyleBuilder": "sideColor,c",
+  "massif::PolygonGeometry": "holes,t;poses,t;rings,t",
+  "massif::PolygonStyle": "lineStyle,o,massif::LineStyle",
+  "massif::PolygonStyleBuilder": "lineStyle,o,massif::LineStyle",
+  "massif::Popup": "anchorPointX,f;anchorPointY,f;style,o,massif::PopupStyle",
+  "massif::PopupClickInfo": "clickInfo,t;clickPos,p;clickType,e,ClickType;elementClickPos,t;popup,o,massif::Popup",
+  "massif::PopupDrawInfo": "DPToPX,f;anchorScreenPos,t;popup,o,massif::Popup;screenBounds,t",
+  "massif::PostProcessEffect": "fragmentShader,s;name,s;terrainDepthRequired,b;terrainNormalsRequired,b",
+  "massif::Projection": "bounds,p;name,s",
+  "massif::RasterTileClickInfo": "clickInfo,t;clickPos,p;clickType,e,ClickType;interpolatedColor,c;layer,o,massif::Layer;mapTile,t;nearestColor,c",
+  "massif::RasterTileLayer": "rasterTileEventListener,o,massif::RasterTileEventListener;textureCacheCapacity,i;tileBlendingSpeed,f;tileFilterMode,e,RasterTileFilterMode",
+  "massif::ReverseGeocodingRequest": "location,p;projection,o,massif::Projection;searchRadius,f",
+  "massif::ReverseGeocodingService": "language,s",
+  "massif::RouteMatchingPoint": "edgeIndex,i;pos,p;type,e,RouteMatchingPointType",
+  "massif::RouteMatchingRequest": "accuracy,f;points,t;projection,o,massif::Projection",
+  "massif::RouteMatchingResult": "matchingEdges,t;matchingPoints,t;points,t;projection,o,massif::Projection;rawResult,s",
+  "massif::RoutingInstruction": "action,e,RoutingAction;azimuth,f;distance,f;geometryTag,v;instruction,s;pointIndex,i;streetName,s;time,f;turnAngle,f",
+  "massif::RoutingRequest": "params,g,v;points,t;projection,o,massif::Projection",
+  "massif::RoutingResult": "instructionCount,i;instructions,t;instructionsJSON,s;pointCount,i;points,t;projection,o,massif::Projection;rawResult,s;totalDistance,f;totalTime,f",
+  "massif::RoutingService": "profile,s",
+  "massif::ScreenBounds": "center,t;max,t;min,t",
+  "massif::ScreenPos": "x,f;y,f",
+  "massif::SearchRequest": "filterExpression,s;geometry,o,massif::Geometry;projection,o,massif::Projection;regexFilter,s;searchRadius,f",
+  "massif::SkyOptions": "atmosphereColor,c;atmosphereLuminance,f;atmosphereSunIntensity,f;enabled,b;groundColor,c;haloColor,c;horizonBlend,f;horizonColor,c;quality,e,SkyQuality;shaderSource,s;skyColor,c;sunDiscEnabled,b;type,e,SkyType",
+  "massif::SolidLayer": "bitmap,o,massif::Bitmap;bitmapScale,f;color,c",
+  "massif::Style": "color,c",
+  "massif::StyleBuilder": "color,c",
+  "massif::TerrainOptions": "autoFlattenDuration,f;autoFlattenParallax,f;autoFlattenRiseDuration,f;autoFlattenTilt,f;backgroundColor,c;billboardOcclusionEnabled,b;billboardOcclusionTolerance,f;bridges3DEnabled,b;cameraClampDuration,f;cameraClearance,f;cameraClearanceFraction,f;depthBias,f;drapeCacheSize,i;drapeFillsEnabled,b;drapeLinesEnabled,b;drapeResolution,i;drapeWorkingSet,i;elevationCacheSize,i;elevationPrefetchEnabled,b;enabled,b;exaggeration,f;flattenMode,e,TerrainFlattenMode;flattenRatio,f;flattened,b;focusLift,f;maxTileZoomCoarsening,i;maxTileZoomOffset,i;maxZoom,i;meshCacheSize,i;meshResolution,i;minZoom,i;noDrapeLayerFilter,s;normalSampleDistance,f;postProcessDownscale,i;seamlessTileEdgesEnabled,b;sharedGroundEnabled,b;subdivideDistance,f;surfaceNodeResolution,i;surfaceShaderSource,s;switching,b;textOcclusionOpacity,f;tileEdgeStitchingEnabled,b;viewDistance,f;viewDistanceFactor,f;viewDistanceMax,f",
+  "massif::Text": "style,o,massif::TextStyle;title,s",
+  "massif::TextMargins": "bottom,i;left,i;right,i;top,i",
+  "massif::TextStyle": "backgroundColor,c;borderColor,c;borderWidth,f;breakLines,b;fontColor,c;fontName,s;fontSize,f;strokeColor,c;strokeWidth,f;textField,s;textMargins,t",
+  "massif::TextStyleBuilder": "backgroundColor,c;borderColor,c;borderWidth,f;breakLines,b;fontName,s;fontSize,f;strokeColor,c;strokeWidth,f;textField,s;textMargins,t",
+  "massif::TileData": "data,o,massif::BinaryData;height,i;maxAge,i;rawPixels,b;replaceWithParent,b;width,i",
+  "massif::TileDataSource": "dataExtent,p;maxOverzoomLevel,i;maxZoom,i;metaData,g,v;minZoom,i;projection,o,massif::Projection",
+  "massif::TileDownloadInfo": "progress,f;tile,t;tileCount,i",
+  "massif::TileLayer": "UTFGridDataSource,o,massif::TileDataSource;UTFGridEventListener,o,massif::UTFGridEventListener;dataSource,o,massif::TileDataSource;frameNr,i;maxOverzoomLevel,i;maxUnderzoomLevel,i;preloading,b;preloadingTileCount,i;projection,o,massif::Projection;synchronizedRefresh,b;tileLoadListener,o,massif::TileLoadListener;tileSubstitutionPolicy,e,TileSubstitutionPolicy;visibleTileCount,i;zoomLevelBias,f",
+  "massif::TomTomOnlineGeocodingService": "customServiceURL,s",
+  "massif::TomTomOnlineReverseGeocodingService": "customServiceURL,s",
+  "massif::TorqueTileDecoder": "animationDuration,f;frameCount,i;resolution,i;styleSet,o,massif::CartoCSSStyleSet",
+  "massif::UTFGridClickInfo": "clickInfo,t;clickPos,p;clickType,e,ClickType;elementInfo,v;layer,o,massif::Layer",
+  "massif::ValhallaOnlineRoutingService": "HTTPHeaders,g,s;customServiceURL,s;timeout,i",
+  "massif::Variant": "arraySize,i;bool,b;double,f;long,i;objectKeys,t;string,s;type,e,VariantType",
+  "massif::VectorData": "elements,t",
+  "massif::VectorDataSource": "dataExtent,p;projection,o,massif::Projection",
+  "massif::VectorElement": "bounds,p;geometry,o,massif::Geometry;id,i;metaData,g,v;visible,b",
+  "massif::VectorElementClickInfo": "clickInfo,t;clickPos,p;clickType,e,ClickType;elementClickPos,p;layer,o,massif::Layer;vectorElement,o,massif::VectorElement",
+  "massif::VectorElementDragInfo": "mapPos,p;screenPos,t;vectorElement,o,massif::VectorElement;vectorElementDragMode,e,VectorElementDragMode",
+  "massif::VectorElementSearchService": "dataSource,o,massif::VectorDataSource;maxResults,i",
+  "massif::VectorLayer": "ZBuffering,b;dataSource,o,massif::VectorDataSource;vectorElementEventListener,o,massif::VectorElementEventListener",
+  "massif::VectorTileClickInfo": "clickInfo,t;clickPos,p;clickType,e,ClickType;feature,o,massif::VectorTileFeature;featureClickPos,p;featureId,i;featureLayerName,s;featurePos,p;featurePosIndex,i;layer,o,massif::Layer;mapTile,t",
+  "massif::VectorTileDecoder": "maxZoom,i;minZoom,i",
+  "massif::VectorTileFeature": "distance,f;id,i;layerName,s;mapTile,t",
+  "massif::VectorTileFeatureBuilder": "id,i;layerName,s;mapTile,t",
+  "massif::VectorTileLayer": "buildingRenderOrder,e,VectorTileRenderOrder;clickHandlerLayerFilter,s;clickRadius,f;labelBlendingSpeed,f;labelPerspectiveScaling,f;labelRenderOrder,e,VectorTileRenderOrder;layerBlendingSpeed,f;rendererLayerFilter,s;tileCacheCapacity,i;tileDecoder,o,massif::VectorTileDecoder;vectorTileEventListener,o,massif::VectorTileEventListener",
+  "massif::VectorTileSearchService": "dataSource,o,massif::TileDataSource;layers,t;maxResults,i;maxZoom,i;minZoom,i;preventDuplicates,b;projection,o,massif::Projection;sortByDistance,b;tileDecoder,o,massif::VectorTileDecoder",
+  "massif::ViewState": "DPI,f;DPToPX,f;FOVY,i;aspectRatio,f;cameraChanged,b;far,f;height,i;near,f;rotation,f;screenHeight,i;screenWidth,i;tilt,f;unitToDPCoef,f;unitToPXCoef,f;width,i;zoom,f;zoom0Distance,f",
+  "massif::WKBGeometryWriter": "bigEndian,b;z,b",
+  "massif::WKTGeometryWriter": "z,b",
+  "massif::ZippedAssetPackage": "localAssetNames,t"
+};
+var ALIASES = {
+  "massif::Options": "background=backgroundBitmap;fog=fogOptions;light=lightOptions;projection=baseProjection;sky=skyOptions;terrain=terrainOptions",
+  "massif::TileLayer": "source=dataSource",
+  "massif::VectorTileLayer": "style=tileDecoder"
+};
+var BASES = {
+  "massif::AssetTileDataSource": "massif::TileDataSource",
+  "massif::BalloonPopup": "massif::Popup",
+  "massif::BalloonPopupButtonStyle": "massif::Style",
+  "massif::BalloonPopupButtonStyleBuilder": "massif::StyleBuilder",
+  "massif::BalloonPopupStyle": "massif::PopupStyle",
+  "massif::BalloonPopupStyleBuilder": "massif::PopupStyleBuilder",
+  "massif::Billboard": "massif::VectorElement",
+  "massif::BillboardStyle": "massif::Style",
+  "massif::BillboardStyleBuilder": "massif::StyleBuilder",
+  "massif::BitmapOverlayRasterTileDataSource": "massif::TileDataSource",
+  "massif::BundleAssetPackage": "massif::AssetPackage",
+  "massif::CacheTileDataSource": "massif::TileDataSource",
+  "massif::CelestialArc": "massif::CelestialObject",
+  "massif::CelestialImage": "massif::CelestialObject",
+  "massif::CelestialLabel": "massif::CelestialObject",
+  "massif::CelestialLayer": "massif::Layer",
+  "massif::CelestialSprite": "massif::CelestialObject",
+  "massif::ClusteredVectorLayer": "massif::VectorLayer",
+  "massif::CombinedTileDataSource": "massif::TileDataSource",
+  "massif::CompositeVectorTileLayer": "massif::VectorTileLayer",
+  "massif::ContourTileDataSource": "massif::TileDataSource",
+  "massif::CustomPopup": "massif::Popup",
+  "massif::CustomRasterTileLayer": "massif::RasterTileLayer",
+  "massif::DirAssetPackage": "massif::AssetPackage",
+  "massif::DouglasPeuckerGeometrySimplifier": "massif::GeometrySimplifier",
+  "massif::DownloadTask": "massif::CancelableTask",
+  "massif::EPSG3857": "massif::Projection",
+  "massif::EPSG4326": "massif::Projection",
+  "massif::EditableVectorLayer": "massif::VectorLayer",
+  "massif::FetchTask": "massif::CancelableTask",
+  "massif::FetchTaskBase": "massif::CancelableTask",
+  "massif::GeoJSONVectorTileDataSource": "massif::TileDataSource",
+  "massif::GeocodingAddress": "massif::Address",
+  "massif::GeometryCollection": "massif::VectorElement",
+  "massif::GeometryCollectionStyle": "massif::Style",
+  "massif::GeometryCollectionStyleBuilder": "massif::StyleBuilder",
+  "massif::HTTPTileDataSource": "massif::TileDataSource",
+  "massif::HillshadeRasterTileLayer": "massif::CustomRasterTileLayer",
+  "massif::Label": "massif::Billboard",
+  "massif::LabelStyle": "massif::BillboardStyle",
+  "massif::LabelStyleBuilder": "massif::BillboardStyleBuilder",
+  "massif::Line": "massif::VectorElement",
+  "massif::LineGeometry": "massif::Geometry",
+  "massif::LineStyle": "massif::Style",
+  "massif::LineStyleBuilder": "massif::StyleBuilder",
+  "massif::LocalVectorDataSource": "massif::VectorDataSource",
+  "massif::MBTilesTileDataSource": "massif::TileDataSource",
+  "massif::MBVectorTileDecoder": "massif::VectorTileDecoder",
+  "massif::MapBoxElevationDataDecoder": "massif::ElevationDecoder",
+  "massif::MapBoxOnlineGeocodingService": "massif::GeocodingService",
+  "massif::MapBoxOnlineReverseGeocodingService": "massif::ReverseGeocodingService",
+  "massif::MapTilerOnlineTileDataSource": "massif::TileDataSource",
+  "massif::Marker": "massif::Billboard",
+  "massif::MarkerStyle": "massif::BillboardStyle",
+  "massif::MarkerStyleBuilder": "massif::BillboardStyleBuilder",
+  "massif::MemoryCacheTileDataSource": "massif::CacheTileDataSource",
+  "massif::MergedMBVTTileDataSource": "massif::TileDataSource",
+  "massif::MultiGeometry": "massif::Geometry",
+  "massif::MultiLineGeometry": "massif::MultiGeometry",
+  "massif::MultiOSMOfflineGeocodingService": "massif::GeocodingService",
+  "massif::MultiOSMOfflineReverseGeocodingService": "massif::ReverseGeocodingService",
+  "massif::MultiPointGeometry": "massif::MultiGeometry",
+  "massif::MultiPolygonGeometry": "massif::MultiGeometry",
+  "massif::MultiTileDataSource": "massif::TileDataSource",
+  "massif::MultiValhallaOfflineRoutingService": "massif::RoutingService",
+  "massif::NMLModel": "massif::Billboard",
+  "massif::NMLModelStyle": "massif::BillboardStyle",
+  "massif::NMLModelStyleBuilder": "massif::BillboardStyleBuilder",
+  "massif::OSMOfflineGeocodingService": "massif::GeocodingService",
+  "massif::OSMOfflineReverseGeocodingService": "massif::ReverseGeocodingService",
+  "massif::OSRMOfflineRoutingService": "massif::RoutingService",
+  "massif::OrderedTileDataSource": "massif::TileDataSource",
+  "massif::PMTilesTileDataSource": "massif::TileDataSource",
+  "massif::PackageManagerGeocodingService": "massif::GeocodingService",
+  "massif::PackageManagerReverseGeocodingService": "massif::ReverseGeocodingService",
+  "massif::PackageManagerRoutingService": "massif::RoutingService",
+  "massif::PackageManagerTileDataSource": "massif::TileDataSource",
+  "massif::PackageManagerValhallaRoutingService": "massif::RoutingService",
+  "massif::PeliasOnlineGeocodingService": "massif::GeocodingService",
+  "massif::PeliasOnlineReverseGeocodingService": "massif::ReverseGeocodingService",
+  "massif::PersistentCacheTileDataSource": "massif::CacheTileDataSource",
+  "massif::Point": "massif::VectorElement",
+  "massif::PointDetailTileDataSource": "massif::TileDataSource",
+  "massif::PointGeometry": "massif::Geometry",
+  "massif::PointStyle": "massif::Style",
+  "massif::PointStyleBuilder": "massif::StyleBuilder",
+  "massif::Polygon": "massif::VectorElement",
+  "massif::Polygon3D": "massif::VectorElement",
+  "massif::Polygon3DStyle": "massif::Style",
+  "massif::Polygon3DStyleBuilder": "massif::StyleBuilder",
+  "massif::PolygonGeometry": "massif::Geometry",
+  "massif::PolygonStyle": "massif::Style",
+  "massif::PolygonStyleBuilder": "massif::StyleBuilder",
+  "massif::Popup": "massif::Billboard",
+  "massif::PopupStyle": "massif::BillboardStyle",
+  "massif::PopupStyleBuilder": "massif::BillboardStyleBuilder",
+  "massif::RasterTileLayer": "massif::TileLayer",
+  "massif::SGREOfflineRoutingService": "massif::RoutingService",
+  "massif::SolidLayer": "massif::Layer",
+  "massif::TerrariumElevationDataDecoder": "massif::ElevationDecoder",
+  "massif::Text": "massif::Label",
+  "massif::TextStyle": "massif::LabelStyle",
+  "massif::TextStyleBuilder": "massif::LabelStyleBuilder",
+  "massif::TileLayer": "massif::Layer",
+  "massif::TomTomOnlineGeocodingService": "massif::GeocodingService",
+  "massif::TomTomOnlineReverseGeocodingService": "massif::ReverseGeocodingService",
+  "massif::TorqueTileDecoder": "massif::VectorTileDecoder",
+  "massif::TorqueTileLayer": "massif::VectorTileLayer",
+  "massif::ValhallaOfflineRoutingService": "massif::RoutingService",
+  "massif::ValhallaOnlineRoutingService": "massif::RoutingService",
+  "massif::VectorLayer": "massif::Layer",
+  "massif::VectorTileFeature": "massif::Feature",
+  "massif::VectorTileFeatureBuilder": "massif::FeatureBuilder",
+  "massif::VectorTileFeatureCollection": "massif::FeatureCollection",
+  "massif::VectorTileLayer": "massif::TileLayer",
+  "massif::ZippedAssetPackage": "massif::AssetPackage"
+};
+var ENUMS = {
+  AnimationType: "ANIMATION_TYPE_NONE=0,ANIMATION_TYPE_STEP=1,ANIMATION_TYPE_LINEAR=2,ANIMATION_TYPE_SMOOTHSTEP=3,ANIMATION_TYPE_SPRING=4",
+  BillboardOrientation: "BILLBOARD_ORIENTATION_FACE_CAMERA=0,BILLBOARD_ORIENTATION_FACE_CAMERA_GROUND=1,BILLBOARD_ORIENTATION_GROUND=2",
+  BillboardScaling: "BILLBOARD_SCALING_WORLD_SIZE=0,BILLBOARD_SCALING_SCREEN_SIZE=1,BILLBOARD_SCALING_CONST_SCREEN_SIZE=2",
+  ClickType: "CLICK_TYPE_SINGLE=0,CLICK_TYPE_LONG=1,CLICK_TYPE_DOUBLE=2,CLICK_TYPE_DUAL=3",
+  ClusterBuilderMode: "CLUSTER_BUILDER_MODE_ELEMENTS=0,CLUSTER_BUILDER_MODE_ELEMENT_COUNT=1",
+  ColorFormat: "COLOR_FORMAT_UNSUPPORTED=0,COLOR_FORMAT_BGRA=1,COLOR_FORMAT_RGBA_4444=2,COLOR_FORMAT_RGB_565=3",
+  CompositeSourceType: "COMPOSITE_SOURCE_TYPE_RASTER=0,COMPOSITE_SOURCE_TYPE_HILLSHADE=1,COMPOSITE_SOURCE_TYPE_VECTOR=2",
+  FlightEasing: "FLIGHT_EASING_EASE=0,FLIGHT_EASING_LINEAR=1,FLIGHT_EASING_EASE_IN=2,FLIGHT_EASING_EASE_OUT=3,FLIGHT_EASING_EASE_IN_OUT=4",
+  FreeRoamMode: "FREE_ROAM_MODE_OFF=0,FREE_ROAM_MODE_LOOK=1,FREE_ROAM_MODE_FIRST_PERSON=2",
+  GeometryType: "GEOMETRY_TYPE_POINT=0,GEOMETRY_TYPE_LINE=1,GEOMETRY_TYPE_POLYGON=2,GEOMETRY_TYPE_MULTIPOINT=3,GEOMETRY_TYPE_MULTILINE=4,GEOMETRY_TYPE_MULTIPOLYGON=5,GEOMETRY_TYPE_COLLECTION=6",
+  HillshadeMethod: "STANDARD=0,COMBINED=1,IGOR=2,MULTIDIRECTIONAL=3,BASIC=4",
+  LineEndType: "LINE_END_TYPE_NONE=0,LINE_END_TYPE_SQUARE=1,LINE_END_TYPE_ROUND=2",
+  LineJoinType: "LINE_JOIN_TYPE_NONE=0,LINE_JOIN_TYPE_MITER=1,LINE_JOIN_TYPE_BEVEL=2,LINE_JOIN_TYPE_ROUND=3",
+  LocalSpatialIndexType: "LOCAL_SPATIAL_INDEX_TYPE_NULL=0,LOCAL_SPATIAL_INDEX_TYPE_KDTREE=1",
+  MBTilesScheme: "MBTILES_SCHEME_TMS=0,MBTILES_SCHEME_XYZ=1",
+  MapMoveReason: "MAP_MOVE_REASON_GESTURE=0,MAP_MOVE_REASON_ANIMATION=1,MAP_MOVE_REASON_API=2",
+  PackageAction: "PACKAGE_ACTION_READY=0,PACKAGE_ACTION_WAITING=1,PACKAGE_ACTION_DOWNLOADING=2,PACKAGE_ACTION_COPYING=3,PACKAGE_ACTION_REMOVING=4",
+  PackageErrorType: "PACKAGE_ERROR_TYPE_SYSTEM=0,PACKAGE_ERROR_TYPE_CONNECTION=1,PACKAGE_ERROR_TYPE_DOWNLOAD_LIMIT_EXCEEDED=2,PACKAGE_ERROR_TYPE_PACKAGE_TOO_BIG=3,PACKAGE_ERROR_TYPE_NO_OFFLINE_PLAN=4",
+  PackageTileStatus: "PACKAGE_TILE_STATUS_MISSING=0,PACKAGE_TILE_STATUS_PARTIAL=1,PACKAGE_TILE_STATUS_FULL=2",
+  PackageType: "PACKAGE_TYPE_MAP=0,PACKAGE_TYPE_ROUTING=1,PACKAGE_TYPE_GEOCODING=2,PACKAGE_TYPE_VALHALLA_ROUTING=3",
+  PanningMode: "PANNING_MODE_FREE=0,PANNING_MODE_STICKY=1,PANNING_MODE_STICKY_FINAL=2",
+  PanningSpeedMode: "PANNING_SPEED_MODE_MAP=0,PANNING_SPEED_MODE_ANCHORED=1,PANNING_SPEED_MODE_CONSTANT=2",
+  PivotMode: "PIVOT_MODE_TOUCHPOINT=0,PIVOT_MODE_CENTERPOINT=1",
+  RasterTileFilterMode: "RASTER_TILE_FILTER_MODE_NEAREST=0,RASTER_TILE_FILTER_MODE_BILINEAR=1,RASTER_TILE_FILTER_MODE_BICUBIC=2",
+  RenderProjectionMode: "RENDER_PROJECTION_MODE_PLANAR=0,RENDER_PROJECTION_MODE_SPHERICAL=1",
+  RouteMatchingPointType: "ROUTE_MATCHING_POINT_UNMATCHED=0,ROUTE_MATCHING_POINT_INTERPOLATED=1,ROUTE_MATCHING_POINT_MATCHED=2",
+  RoutingAction: "ROUTING_ACTION_HEAD_ON=0,ROUTING_ACTION_FINISH=1,ROUTING_ACTION_NO_TURN=2,ROUTING_ACTION_GO_STRAIGHT=3,ROUTING_ACTION_TURN_RIGHT=4,ROUTING_ACTION_UTURN=5,ROUTING_ACTION_TURN_LEFT=6,ROUTING_ACTION_REACH_VIA_LOCATION=7,ROUTING_ACTION_ENTER_ROUNDABOUT=8,ROUTING_ACTION_LEAVE_ROUNDABOUT=9,ROUTING_ACTION_STAY_ON_ROUNDABOUT=10,ROUTING_ACTION_START_AT_END_OF_STREET=11,ROUTING_ACTION_ENTER_AGAINST_ALLOWED_DIRECTION=12,ROUTING_ACTION_LEAVE_AGAINST_ALLOWED_DIRECTION=13,ROUTING_ACTION_GO_UP=14,ROUTING_ACTION_GO_DOWN=15,ROUTING_ACTION_WAIT=16,ROUTING_ACTION_ENTER_FERRY=17,ROUTING_ACTION_LEAVE_FERRY=18",
+  SkyQuality: "SKY_QUALITY_LOW=0,SKY_QUALITY_MEDIUM=1,SKY_QUALITY_HIGH=2",
+  SkyType: "SKY_TYPE_GRADIENT=0,SKY_TYPE_ATMOSPHERE=1",
+  TerrainFlattenMode: "TERRAIN_FLATTEN_MODE_RENDER=0,TERRAIN_FLATTEN_MODE_FULL=1",
+  TileFormat: "TILE_FORMAT_AUTO=0,TILE_FORMAT_MVT=1,TILE_FORMAT_MLT=2",
+  TileLODProfile: "TILE_LOD_PROFILE_REFERENCE=0,TILE_LOD_PROFILE_MOBILE=1,TILE_LOD_PROFILE_DESKTOP=2",
+  TileSubstitutionPolicy: "TILE_SUBSTITUTION_POLICY_ALL=0,TILE_SUBSTITUTION_POLICY_VISIBLE=1,TILE_SUBSTITUTION_POLICY_NONE=2",
+  VariantType: "VARIANT_TYPE_NULL=0,VARIANT_TYPE_STRING=1,VARIANT_TYPE_BOOL=2,VARIANT_TYPE_INTEGER=3,VARIANT_TYPE_DOUBLE=4,VARIANT_TYPE_ARRAY=5,VARIANT_TYPE_OBJECT=6",
+  VectorElementDragMode: "VECTOR_ELEMENT_DRAG_MODE_VERTEX=0,VECTOR_ELEMENT_DRAG_MODE_ELEMENT=1",
+  VectorElementDragPointStyle: "VECTOR_ELEMENT_DRAG_POINT_STYLE_NORMAL=0,VECTOR_ELEMENT_DRAG_POINT_STYLE_VIRTUAL=1,VECTOR_ELEMENT_DRAG_POINT_STYLE_SELECTED=2",
+  VectorElementDragResult: "VECTOR_ELEMENT_DRAG_RESULT_IGNORE=0,VECTOR_ELEMENT_DRAG_RESULT_STOP=1,VECTOR_ELEMENT_DRAG_RESULT_MODIFY=2,VECTOR_ELEMENT_DRAG_RESULT_DELETE=3",
+  VectorTileRenderOrder: "VECTOR_TILE_RENDER_ORDER_HIDDEN=-1,VECTOR_TILE_RENDER_ORDER_LAYER=0,VECTOR_TILE_RENDER_ORDER_LAST=1",
+  massifChangeType: "PACKAGES_ADDED=0,PACKAGES_DELETED=1",
+  massifCommand: "NOP=0,DOWNLOAD_PACKAGE_LIST=1,DOWNLOAD_PACKAGE=2,IMPORT_PACKAGE=3,REMOVE_PACKAGE=4,DOWNLOAD_STYLE=5",
+  massifPackageChangeType: "PACKAGES_UPDATED=0,PACKAGES_ADDED=1,PACKAGES_DELETED=2"
+};
+var SPEC_CLASS = {
+  "assets": { "bundle": "massif::BundleAssetPackage", "dir": "massif::DirAssetPackage", "zip": "massif::ZippedAssetPackage" },
+  "celestial": { "arc": "massif::CelestialArc", "image": "massif::CelestialImage", "label": "massif::CelestialLabel", "sprite": "massif::CelestialSprite" },
+  "effect": { "postprocess": "massif::PostProcessEffect" },
+  "element": { "balloon": "massif::BalloonPopup", "line": "massif::Line", "marker": "massif::Marker", "point": "massif::Point", "polygon": "massif::Polygon", "text": "massif::Text" },
+  "elementstyle": { "balloon": "massif::BalloonPopupStyle", "line": "massif::LineStyle", "marker": "massif::MarkerStyle", "point": "massif::PointStyle", "polygon": "massif::PolygonStyle", "text": "massif::TextStyle" },
+  "feature": { "feature": "massif::Feature" },
+  "geocoding": { "multi-osm-offline": "massif::MultiOSMOfflineGeocodingService", "multi-osm-offline-reverse": "massif::MultiOSMOfflineReverseGeocodingService" },
+  "geometry": { "line": "massif::LineGeometry", "point": "massif::PointGeometry", "polygon": "massif::PolygonGeometry" },
+  "layer": { "celestial": "massif::CelestialLayer", "composite-vector": "massif::CompositeVectorTileLayer", "elements": "massif::VectorLayer", "hillshade": "massif::HillshadeRasterTileLayer", "raster": "massif::RasterTileLayer", "solid": "massif::SolidLayer", "vector": "massif::VectorTileLayer" },
+  "options": { "fog": "massif::FogOptions", "light": "massif::LightOptions", "sky": "massif::SkyOptions", "terrain": "massif::TerrainOptions" },
+  "routing": { "multi-valhalla-offline": "massif::MultiValhallaOfflineRoutingService", "valhalla-offline": "massif::ValhallaOfflineRoutingService", "valhalla-online": "massif::ValhallaOnlineRoutingService" },
+  "search": { "request": "massif::SearchRequest", "vectortile": "massif::VectorTileSearchService" },
+  "source": { "assets": "massif::AssetTileDataSource", "combined": "massif::CombinedTileDataSource", "contour": "massif::ContourTileDataSource", "geojson": "massif::GeoJSONVectorTileDataSource", "http": "massif::HTTPTileDataSource", "local": "massif::LocalVectorDataSource", "maptiler": "massif::MapTilerOnlineTileDataSource", "mbtiles": "massif::MBTilesTileDataSource", "memory-cache": "massif::MemoryCacheTileDataSource", "merged-mbvt": "massif::MergedMBVTTileDataSource", "multi": "massif::MultiTileDataSource", "ordered": "massif::OrderedTileDataSource", "persistent-cache": "massif::PersistentCacheTileDataSource", "pmtiles": "massif::PMTilesTileDataSource", "point-detail": "massif::PointDetailTileDataSource" },
+  "style": { "mbvt": "massif::MBVectorTileDecoder" },
+  "styleset": { "cartocss": "massif::CartoCSSStyleSet", "project": "massif::CompiledStyleSet" }
+};
+var KIND_OF_CLASS = {
+  "massif::AssetPackage": "assets",
+  "massif::AssetTileDataSource": "source",
+  "massif::BalloonPopup": "element",
+  "massif::BalloonPopupStyle": "elementstyle",
+  "massif::BalloonPopupStyleBuilder": "elementstyle",
+  "massif::Billboard": "element",
+  "massif::BillboardStyle": "elementstyle",
+  "massif::BillboardStyleBuilder": "elementstyle",
+  "massif::BinaryData": "data",
+  "massif::Bitmap": "bitmap",
+  "massif::BundleAssetPackage": "assets",
+  "massif::CacheTileDataSource": "source",
+  "massif::CartoCSSStyleSet": "styleset",
+  "massif::CelestialArc": "celestial",
+  "massif::CelestialImage": "celestial",
+  "massif::CelestialLabel": "celestial",
+  "massif::CelestialLayer": "layer",
+  "massif::CelestialObject": "celestial",
+  "massif::CelestialSprite": "celestial",
+  "massif::CombinedTileDataSource": "source",
+  "massif::CompiledStyleSet": "styleset",
+  "massif::CompositeVectorTileLayer": "layer",
+  "massif::ContourTileDataSource": "source",
+  "massif::CustomRasterTileLayer": "layer",
+  "massif::DirAssetPackage": "assets",
+  "massif::Feature": "feature",
+  "massif::FogOptions": "options",
+  "massif::GeoJSONVectorTileDataSource": "source",
+  "massif::GeocodingRequest": "geocoding",
+  "massif::GeocodingService": "geocoding",
+  "massif::Geometry": "geometry",
+  "massif::HTTPTileDataSource": "source",
+  "massif::HillshadeRasterTileLayer": "layer",
+  "massif::Label": "element",
+  "massif::LabelStyle": "elementstyle",
+  "massif::LabelStyleBuilder": "elementstyle",
+  "massif::Layer": "layer",
+  "massif::LightOptions": "options",
+  "massif::Line": "element",
+  "massif::LineGeometry": "geometry",
+  "massif::LineStyle": "elementstyle",
+  "massif::LineStyleBuilder": "elementstyle",
+  "massif::LocalVectorDataSource": "source",
+  "massif::MBTilesTileDataSource": "source",
+  "massif::MBVectorTileDecoder": "style",
+  "massif::MapTilerOnlineTileDataSource": "source",
+  "massif::Marker": "element",
+  "massif::MarkerStyle": "elementstyle",
+  "massif::MarkerStyleBuilder": "elementstyle",
+  "massif::MemoryCacheTileDataSource": "source",
+  "massif::MergedMBVTTileDataSource": "source",
+  "massif::MultiOSMOfflineGeocodingService": "geocoding",
+  "massif::MultiOSMOfflineReverseGeocodingService": "geocoding",
+  "massif::MultiTileDataSource": "source",
+  "massif::MultiValhallaOfflineRoutingService": "routing",
+  "massif::OrderedTileDataSource": "source",
+  "massif::PMTilesTileDataSource": "source",
+  "massif::PersistentCacheTileDataSource": "source",
+  "massif::Point": "element",
+  "massif::PointDetailTileDataSource": "source",
+  "massif::PointGeometry": "geometry",
+  "massif::PointStyle": "elementstyle",
+  "massif::PointStyleBuilder": "elementstyle",
+  "massif::Polygon": "element",
+  "massif::PolygonGeometry": "geometry",
+  "massif::PolygonStyle": "elementstyle",
+  "massif::PolygonStyleBuilder": "elementstyle",
+  "massif::Popup": "element",
+  "massif::PopupStyle": "elementstyle",
+  "massif::PopupStyleBuilder": "elementstyle",
+  "massif::PostProcessEffect": "effect",
+  "massif::Projection": "projection",
+  "massif::RasterTileLayer": "layer",
+  "massif::ReverseGeocodingRequest": "geocoding",
+  "massif::ReverseGeocodingService": "geocoding",
+  "massif::RouteMatchingRequest": "routing",
+  "massif::RoutingRequest": "routing",
+  "massif::RoutingService": "routing",
+  "massif::SearchRequest": "search",
+  "massif::SkyOptions": "options",
+  "massif::SolidLayer": "layer",
+  "massif::Style": "elementstyle",
+  "massif::StyleBuilder": "elementstyle",
+  "massif::TerrainOptions": "options",
+  "massif::Text": "element",
+  "massif::TextStyle": "elementstyle",
+  "massif::TextStyleBuilder": "elementstyle",
+  "massif::TileDataSource": "source",
+  "massif::TileLayer": "layer",
+  "massif::ValhallaOfflineRoutingService": "routing",
+  "massif::ValhallaOnlineRoutingService": "routing",
+  "massif::VectorDataSource": "source",
+  "massif::VectorElement": "element",
+  "massif::VectorLayer": "layer",
+  "massif::VectorTileDecoder": "style",
+  "massif::VectorTileLayer": "layer",
+  "massif::VectorTileSearchService": "search",
+  "massif::ZippedAssetPackage": "assets"
+};
+var METHODS = {
+  "massif::BaseMapView": "fitBounds,v;flyTo,v;mapToScreen,j;moveCameraTo,v;moveTo,v;screenToMap,j;stopFlight,v",
+  "massif::CelestialArc": "setCircle,v;setDirections,v;setSegments,v",
+  "massif::CelestialImage": "setAnchors,v",
+  "massif::CelestialLabel": "setAnchorPoint,v;setOffset,v",
+  "massif::CelestialLayer": "add,v;clear,v;remove,b",
+  "massif::CelestialObject": "setDirection,v",
+  "massif::CompositeVectorTileLayer": "addExternalDataSource,v;addVectorDataSource,v;getExternalChildLayer,o,massif::Layer;getExternalDataSourceNames,j;removeExternalDataSource,b;setExternalDataSourceMaxOverzoomLevel,v;setExternalDataSourceZoomLevelBias,v",
+  "massif::FeatureCollection": "getFeature,o,massif::Feature",
+  "massif::FeatureCollectionSearchService": "findFeatures,o,massif::FeatureCollection",
+  "massif::GeoJSONVectorTileDataSource": "addFeature,v;createLayer,i;deleteLayer,v;removeFeature,v;setLayerGeoJSON,v;updateFeature,v",
+  "massif::GeocodingService": "calculateAddresses,j",
+  "massif::HillshadeRasterTileLayer": "getElevation,f;getElevations,d",
+  "massif::Layer": "refresh,v",
+  "massif::Layers": "add,v;clear,v;get,o,massif::Layer;insert,v;remove,b;set,v",
+  "massif::LightOptions": "setSunPositionFromTime,v",
+  "massif::LocalVectorDataSource": "add,v;clear,v;remove,b",
+  "massif::MBVectorTileDecoder": "addFallbackFont,v;getLegend,j;getStyleParameter,s;setStyleParameter,b;setStyleParameters,v",
+  "massif::MultiOSMOfflineGeocodingService": "add,v;remove,b",
+  "massif::MultiOSMOfflineReverseGeocodingService": "add,v;remove,b",
+  "massif::MultiTileDataSource": "add,v;remove,b",
+  "massif::MultiValhallaOfflineRoutingService": "add,v;addLocale,v;remove,b;setConfigurationParameter,v",
+  "massif::PersistentCacheTileDataSource": "clear,v;startDownloadArea,v;stopAllDownloads,v",
+  "massif::PostProcessEffect": "setFloatParameter,v",
+  "massif::ReverseGeocodingService": "calculateAddresses,j",
+  "massif::RouteMatchingRequest": "setCustomParameter,v",
+  "massif::RoutingRequest": "setCustomParameter,v",
+  "massif::RoutingResult": "getInstruction,o,massif::RoutingInstruction;getPoints,d",
+  "massif::RoutingService": "calculateRoute,o,massif::RoutingResult;matchRoute,o,massif::RouteMatchingResult",
+  "massif::TerrainOptions": "calculateHorizon,d;setSurfaceParameter,v",
+  "massif::TileData": "getMetaDataElement,j",
+  "massif::TileDataSource": "getMetaDataElement,j;loadTile,o,massif::TileData;setMetaDataElement,v",
+  "massif::TileLayer": "clearTileCaches,v",
+  "massif::VectorTileFeatureCollection": "getFeature,o,massif::VectorTileFeature",
+  "massif::VectorTileSearchService": "findFeatures,o,massif::VectorTileFeatureCollection"
+};
+var EVENTS = {
+  "massif::CelestialLayer": { "celestial.clicked": { payload: "massif::CelestialClickInfo", consume: true }, "sky.clicked": { payload: "massif::CelestialClickInfo", consume: true } },
+  "massif::Options": { "map.clicked": { payload: "massif::MapClickInfo", consume: false }, "map.idle": { payload: "", consume: false }, "map.interaction": { payload: "massif::MapInteractionInfo", consume: false }, "map.moved": { payload: "massif::MapMoveInfo", consume: false }, "map.stable": { payload: "massif::MapMoveInfo", consume: false } },
+  "massif::PersistentCacheTileDataSource": { "download.completed": { payload: "", consume: false }, "download.failed": { payload: "massif::TileDownloadInfo", consume: false }, "download.progress": { payload: "massif::TileDownloadInfo", consume: false }, "download.started": { payload: "massif::TileDownloadInfo", consume: false } },
+  "massif::VectorLayer": { "vectorelement.clicked": { payload: "massif::VectorElementClickInfo", consume: true } },
+  "massif::VectorTileLayer": { "vectortile.clicked": { payload: "massif::VectorTileClickInfo", consume: true } }
+};
+var CLASS_NAMES = "Address,AnimationStyle,AnimationStyleBuilder,AssetPackage,AssetTileDataSource,BalloonPopup,BalloonPopupButton,BalloonPopupButtonClickInfo,BalloonPopupButtonStyle,BalloonPopupButtonStyleBuilder,BalloonPopupEventListener,BalloonPopupMargins,BalloonPopupStyle,BalloonPopupStyleBuilder,BaseMapView,Billboard,BillboardStyle,BillboardStyleBuilder,BinaryData,Bitmap,BitmapOverlayRasterTileDataSource,BundleAssetPackage,CacheTileDataSource,CartoCSSStyleSet,CelestialArc,CelestialClickInfo,CelestialEventListener,CelestialImage,CelestialLabel,CelestialLayer,CelestialObject,CelestialSprite,ClickInfo,ClusterElementBuilder,ClusterFetchTask,ClusteredVectorLayer,Color,CombinedTileDataSource,CompiledStyleSet,CompositeVectorTileLayer,ContourTileDataSource,CullState,CustomPopup,CustomPopupHandler,CustomRasterTileLayer,DataSourceListener,DirAssetPackage,DouglasPeuckerGeometrySimplifier,DownloadTask,EPSG3857,EPSG4326,EditableVectorLayer,ElevationDecoder,EventListener,Feature,FeatureBuilder,FeatureCollection,FeatureCollectionSearchService,FetchTask,FetchTaskBase,FetchingTasks,FetchingTileTasks,FogOptions,GeoJSONGeometryReader,GeoJSONGeometryWriter,GeoJSONVectorTileDataSource,GeocodingAddress,GeocodingRequest,GeocodingResult,GeocodingService,Geometry,GeometryCollection,GeometryCollectionStyle,GeometryCollectionStyleBuilder,GeometrySimplifier,HTTPTileDataSource,HillshadeRasterTileLayer,Label,LabelStyle,LabelStyleBuilder,Layer,Layers,LightOptions,LightStop,Line,LineGeometry,LineStyle,LineStyleBuilder,LocalVectorDataSource,Log,LogEventListener,MBTilesTileDataSource,MBVectorTileDecoder,ManeuverArrowBuilder,MapBounds,MapBoxElevationDataDecoder,MapBoxOnlineGeocodingService,MapBoxOnlineReverseGeocodingService,MapClickInfo,MapEnvelope,MapEventListener,MapInteractionInfo,MapMoveInfo,MapPos,MapRange,MapRenderer,MapRendererListener,MapTile,MapTilerOnlineTileDataSource,MapVec,Marker,MarkerStyle,MarkerStyleBuilder,MassifApi,MassifInterop,MemoryCacheTileDataSource,MergedMBVTTileDataSource,MultiGeometry,MultiLineGeometry,MultiOSMOfflineGeocodingService,MultiOSMOfflineReverseGeocodingService,MultiPointGeometry,MultiPolygonGeometry,MultiTileDataSource,MultiValhallaOfflineRoutingService,NMLModel,NMLModelStyle,NMLModelStyleBuilder,OSMOfflineGeocodingService,OSMOfflineReverseGeocodingService,OSRMOfflineRoutingService,OnChangeListener,Options,OptionsListener,OrderedTileDataSource,PMTilesTileDataSource,PackageInfo,PackageManager,PackageManagerGeocodingService,PackageManagerListener,PackageManagerReverseGeocodingService,PackageManagerRoutingService,PackageManagerTileDataSource,PackageManagerValhallaRoutingService,PackageMetaInfo,PackageStatus,PackageTileMask,PeliasOnlineGeocodingService,PeliasOnlineReverseGeocodingService,PersistentCacheTileDataSource,PersistentTaskQueue,Point,PointDetailTileDataSource,PointGeometry,PointStyle,PointStyleBuilder,Polygon,Polygon3D,Polygon3DStyle,Polygon3DStyleBuilder,PolygonGeometry,PolygonStyle,PolygonStyleBuilder,Popup,PopupClickInfo,PopupDrawInfo,PopupStyle,PopupStyleBuilder,PostProcessEffect,Projection,RasterTileClickInfo,RasterTileEventListener,RasterTileLayer,RedrawRequestListener,RendererCaptureListener,ReverseGeocodingRequest,ReverseGeocodingService,RouteMatchingEdge,RouteMatchingPoint,RouteMatchingRequest,RouteMatchingResult,RoutingInstruction,RoutingRequest,RoutingResult,RoutingService,SGREOfflineRoutingService,ScreenBounds,ScreenPos,SearchRequest,SkyOptions,SolidLayer,Style,StyleBuilder,TerrainOptions,TerrariumElevationDataDecoder,Text,TextMargins,TextStyle,TextStyleBuilder,TileData,TileDataSource,TileDecoderListener,TileDownloadInfo,TileDownloadListener,TileInfo,TileLayer,TileLoadListener,TileUtils,TomTomOnlineGeocodingService,TomTomOnlineReverseGeocodingService,TorqueTileDecoder,TorqueTileLayer,TouchHandlerListener,UTFGridClickInfo,UTFGridEventListener,UiDispatcher,ValhallaOfflineRoutingService,ValhallaOnlineRoutingService,Variant,VariantArrayBuilder,VariantObjectBuilder,VectorData,VectorDataSource,VectorEditEventListener,VectorElement,VectorElementClickInfo,VectorElementDragInfo,VectorElementEventListener,VectorElementSearchService,VectorLayer,VectorTileClickInfo,VectorTileDecoder,VectorTileEventListener,VectorTileFeature,VectorTileFeatureBuilder,VectorTileFeatureCollection,VectorTileLayer,VectorTileSearchService,ViewState,WKBGeometryReader,WKBGeometryWriter,WKTGeometryReader,WKTGeometryWriter,ZippedAssetPackage";
+
+// ../../bindings/js/dist/resolve.js
+var propCache = {};
+var aliasCache = {};
+var methodCache = {};
+function parseProps(cls) {
+  let table = propCache[cls];
+  if (!table) {
+    table = propCache[cls] = {};
+    const encoded = PROPS[cls];
+    if (encoded) {
+      for (const entry of encoded.split(";")) {
+        const [name, code, arg] = entry.split(",");
+        table[name] = arg ? { code, arg } : { code };
+      }
+    }
+  }
+  return table;
+}
+function parseAliases(cls) {
+  let table = aliasCache[cls];
+  if (!table) {
+    table = aliasCache[cls] = {};
+    const encoded = ALIASES[cls];
+    if (encoded) {
+      for (const entry of encoded.split(";")) {
+        const [alias, path] = entry.split("=");
+        table[alias] = path;
+      }
+    }
+  }
+  return table;
+}
+function parseMethods(cls) {
+  let table = methodCache[cls];
+  if (!table) {
+    table = methodCache[cls] = {};
+    const encoded = METHODS[cls];
+    if (encoded) {
+      for (const entry of encoded.split(";")) {
+        const [name, code, arg] = entry.split(",");
+        table[name] = arg ? { code, arg } : { code };
+      }
+    }
+  }
+  return table;
+}
+function propertyNames(cls) {
+  const names2 = [];
+  let walk = cls;
+  while (walk) {
+    for (const name of Object.keys(parseProps(walk))) {
+      if (names2.indexOf(name) < 0) {
+        names2.push(name);
+      }
+    }
+    walk = BASES[walk];
+  }
+  return names2;
+}
+function findProperty(cls, name) {
+  let walk = cls;
+  while (walk) {
+    const found = parseProps(walk)[name] ?? parseProps(walk)[parseAliases(walk)[name]];
+    if (found) {
+      return found;
+    }
+    walk = BASES[walk];
+  }
+  return null;
+}
+function resolvePath(cls, path) {
+  if (!path) {
+    return null;
+  }
+  const segments = path.split(".");
+  let current = cls;
+  for (let i = 0; i < segments.length; i++) {
+    const prop = findProperty(current, segments[i]);
+    if (!prop) {
+      return null;
+    }
+    if (i === segments.length - 1) {
+      return prop.code === "g" ? { code: "v" } : prop;
+    }
+    if (prop.code === "o") {
+      current = prop.arg;
+      continue;
+    }
+    if (prop.code === "g") {
+      return { code: prop.arg ?? "s" };
+    }
+    return prop.code === "t" || prop.code === "p" || prop.code === "v" ? { code: "v" } : null;
+  }
+  return null;
+}
+function findMethod(cls, name) {
+  let walk = cls;
+  while (walk) {
+    const found = parseMethods(walk)[name];
+    if (found) {
+      return found;
+    }
+    walk = BASES[walk];
+  }
+  return null;
+}
+function resolveMethod(cls, path) {
+  const cut = path.lastIndexOf(".");
+  if (cut < 0) {
+    return findMethod(cls, path);
+  }
+  const owner = resolvePath(cls, path.substring(0, cut));
+  return owner && owner.code === "o" ? findMethod(owner.arg, path.substring(cut + 1)) : null;
+}
+function findEvent(cls, event) {
+  let walk = cls;
+  while (walk) {
+    const table = EVENTS[walk];
+    if (table && event in table) {
+      return table[event];
+    }
+    walk = BASES[walk];
+  }
+  return null;
+}
+function eventNames(cls) {
+  const names2 = [];
+  let walk = cls;
+  while (walk) {
+    for (const name of Object.keys(EVENTS[walk] ?? {})) {
+      if (names2.indexOf(name) < 0) {
+        names2.push(name);
+      }
+    }
+    walk = BASES[walk];
+  }
+  return names2;
+}
+var enumTables;
+function tables() {
+  if (!enumTables) {
+    const built = { byName: {}, byValue: {} };
+    for (const enumType of Object.keys(ENUMS)) {
+      const reverse = built.byValue[enumType] = {};
+      for (const member of ENUMS[enumType].split(",")) {
+        const cut = member.lastIndexOf("=");
+        const name = member.substring(0, cut);
+        const value = member.substring(cut + 1);
+        built.byName[name] = Number(value);
+        reverse[value] = name;
+      }
+    }
+    enumTables = built;
+  }
+  return enumTables;
+}
+function enumValue(name) {
+  return tables().byName[name];
+}
+function enumName(enumType, value) {
+  const table = enumType ? tables().byValue[enumType] : void 0;
+  return table && table[value] !== void 0 ? table[value] : value;
+}
+function classOfSpec(kind, type) {
+  return SPEC_CLASS[kind]?.[type] ?? null;
+}
+function specKindOf(cppClass) {
+  return KIND_OF_CLASS[cppClass] ?? null;
+}
+var known;
+function knownClasses() {
+  if (!known) {
+    known = {};
+    for (const name of CLASS_NAMES.split(",")) {
+      known[name] = true;
+    }
+  }
+  return known;
+}
+function classOfShortName(short) {
+  return short && knownClasses()[short] ? `massif::${short}` : null;
+}
+function isKnownClass(cls) {
+  return !!knownClasses()[cls.replace("massif::", "")];
+}
+function isSubclassOf(cls, base) {
+  let walk = cls;
+  while (walk) {
+    if (walk === base) {
+      return true;
+    }
+    walk = BASES[walk];
+  }
+  return false;
+}
+
+// ../../bindings/js/dist/index.js
+var Result = {
+  OK: 0,
+  BAD_HANDLE: 1,
+  UNKNOWN_CLASS: 2,
+  UNKNOWN_PROPERTY: 3,
+  READONLY: 4,
+  UNSUPPORTED_TYPE: 5,
+  NULL_OBJECT: 8
+};
+var MassifApiError = class extends Error {
+  constructor(message, result) {
+    super(message);
+    this.result = result;
+    this.name = "MassifApiError";
+  }
+};
+function isAvailable() {
+  return bridge.available;
+}
+function canConsume() {
+  return bridge.canConsume;
+}
+function requireApi() {
+  if (!bridge.available) {
+    throw new MassifApiError("this MassifMaps build has no surface API - the SDK was built without all/native/api");
+  }
+}
+var DELIVERY_ORIGIN = 0;
+var payloadProtos = {};
+function payloadProto(payloadClass) {
+  let proto = payloadProtos[payloadClass];
+  if (!proto) {
+    proto = payloadProtos[payloadClass] = {};
+    for (const name of propertyNames(payloadClass)) {
+      Object.defineProperty(proto, name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return this.get(name);
+        }
+      });
+    }
+  }
+  return proto;
+}
+var Subscription = class {
+  constructor(id) {
+    this.id = id;
+    this.mRemoved = false;
+    this.mCancelPending = null;
+  }
+  get valid() {
+    return !this.mRemoved;
+  }
+  remove() {
+    if (this.mRemoved) {
+      return false;
+    }
+    this.mRemoved = true;
+    if (this.mCancelPending) {
+      this.mCancelPending();
+      this.mCancelPending = null;
+    }
+    return bridge.off(this.id);
+  }
+  /** @internal */
+  onRemove(cancel) {
+    this.mCancelPending = cancel;
+  }
+};
+function parseJson(text) {
+  if (text === null || text === "") {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return text;
+  }
+}
+function isSpec(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof MassifObject) && typeof value.handle !== "number" && typeof value.type === "string";
+}
+function handleOf(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (value && typeof value.handle === "number") {
+    return value.handle;
+  }
+  return 0;
+}
+function toPosition(position) {
+  if (Array.isArray(position)) {
+    return position;
+  }
+  const lng = position.longitude ?? position.lng ?? position.lon;
+  const lat = position.latitude ?? position.lat;
+  const altitude = position.altitude ?? position.alt;
+  if (lng === void 0 || lat === void 0) {
+    throw new MassifApiError(`not a position: ${JSON.stringify(position)}`);
+  }
+  return altitude ? [lng, lat, altitude] : [lng, lat];
+}
+function argsJson(args) {
+  return JSON.stringify(args.map((a) => a instanceof MassifObject ? a.handle : a));
+}
+var PropertyGroup = class {
+  constructor(owner, prefix, className) {
+    this.owner = owner;
+    this.prefix = prefix;
+    this.className = className;
+  }
+  /** The full path this group would write, for logging or for a raw call. */
+  path(path) {
+    return this.prefix ? `${this.prefix}.${path}` : path;
+  }
+  get(path) {
+    return this.owner.get(this.path(path));
+  }
+  set(path, value) {
+    this.owner.set(this.path(path), value);
+    return this;
+  }
+  /** Applies several properties in one call, prefixed - so the owner batches them as one. */
+  apply(values) {
+    const prefixed = {};
+    for (const key of Object.keys(values)) {
+      prefixed[this.path(key)] = values[key];
+    }
+    this.owner.apply(prefixed);
+    return this;
+  }
+  getPos(path, projection) {
+    return this.owner.getPos(this.path(path), projection);
+  }
+  group(path) {
+    return this.owner.group(this.path(path));
+  }
+  /** @see MassifObject.child */
+  child(path) {
+    return this.owner.child(this.path(path));
+  }
+};
+var MassifObject = class _MassifObject extends Observable {
+  constructor(handle, className, id) {
+    super();
+    this.handle = handle;
+    this.className = className;
+    this.id = id;
+    this.mSubscriptions = {};
+    this.mDefaults = {};
+    this.mDestroyed = false;
+  }
+  /**
+   * Whether this object is of a class, or of one below it.
+   *
+   * `instanceof`, for an API that addresses classes by name: `layer.is('massif::RasterTileLayer')`
+   * is how an app asks "is this one of the raster ones" without the SDK's proxy classes.
+   */
+  is(className) {
+    return isSubclassOf(this.className, className);
+  }
+  /** Whether the handle still resolves. False after `destroy`, and after the id was dropped. */
+  get valid() {
+    return !this.mDestroyed && bridge.isValid(this.handle);
+  }
+  // --- properties ---------------------------------------------------------------------------
+  /**
+   * Reads a property.
+   *
+   * The path may walk object properties (`fogOptions.rangeStart`), into a struct
+   * (`clickInfo.clickType`) and into free-form data (`properties.name`). An enum comes back as
+   * its constant name, a position as `[lon, lat]`, a struct as the JSON it encodes.
+   */
+  get(path) {
+    return this.read(path);
+  }
+  read(path) {
+    const info = resolvePath(this.className, path);
+    switch (info?.code) {
+      case "b":
+        return bridge.getBool(this.handle, path, false);
+      case "i":
+      case "c":
+        return bridge.getInt(this.handle, path, 0);
+      case "f":
+        return bridge.getFloat(this.handle, path, 0);
+      case "s":
+        return bridge.getString(this.handle, path);
+      case "e":
+        return enumName(info.arg, bridge.getInt(this.handle, path, 0));
+      case "p":
+        return parseJson(bridge.getPos(this.handle, path, ""));
+      case "t":
+        return parseJson(bridge.getString(this.handle, path));
+      case "o":
+        throw new MassifApiError(`${path} is an object property - reach it with group('${path}'), child('${path}') or read a path through it`);
+      default:
+        return parseJson(bridge.getString(this.handle, path));
+    }
+  }
+  /**
+   * Writes a property. Every path but an object one takes the JavaScript value directly - an
+   * enum by its constant name, a position as an array.
+   */
+  set(path, value) {
+    const result = this.write(path, value);
+    if (result !== Result.OK) {
+      throw new MassifApiError(`${this.className}.${path}: ${resultName(result)}`, result);
+    }
+    return this;
+  }
+  /** The same without throwing, for a path that may legitimately not be there. */
+  trySet(path, value) {
+    return this.write(path, value);
+  }
+  write(path, value) {
+    const info = resolvePath(this.className, path);
+    switch (info?.code) {
+      case "b":
+        return bridge.setBool(this.handle, path, !!value);
+      case "i":
+      case "c":
+        return bridge.setInt(this.handle, path, value);
+      case "f":
+        return bridge.setFloat(this.handle, path, value);
+      case "s":
+        return bridge.setString(this.handle, path, String(value));
+      case "e":
+        return bridge.setInt(this.handle, path, enumValue(String(value)) ?? Number(value));
+      case "o":
+        return isSpec(value) ? this.writeSpec(path, info.arg, value) : bridge.setObject(this.handle, path, handleOf(value));
+      case "p":
+      case "t":
+      case "v":
+        return bridge.setString(this.handle, path, JSON.stringify(value));
+      default:
+        return this.writeByType(path, value);
+    }
+  }
+  /**
+   * An OBJECT property written from an INLINE SPEC, the way a constructor argument takes one.
+   *
+   * `setObject` carries a handle and nothing else, so a spec used to collapse to NULL_HANDLE -
+   * which CLEARS the property and returns OK. Setting `backgroundBitmap` that way blanked the
+   * map background and reported success.
+   *
+   * The built object is registered under an id derived from the target, so it stays alive as
+   * long as the property points at it and a second write replaces it rather than leaking.
+   */
+  writeSpec(path, objectClass, spec) {
+    const kind = specKindOf(objectClass);
+    if (!kind) {
+      return Result.UNKNOWN_CLASS;
+    }
+    const id = `${this.id ?? this.handle}.${path}`;
+    find(kind, id, objectClass)?.destroy();
+    const built = create(kind, id, spec, objectClass);
+    return bridge.setObject(this.handle, path, built.handle);
+  }
+  /** The fallback for a path the tables cannot resolve: pick the verb from the value. */
+  writeByType(path, value) {
+    if (typeof value === "boolean") {
+      return bridge.setBool(this.handle, path, value);
+    }
+    if (typeof value === "number") {
+      return bridge.setFloat(this.handle, path, value);
+    }
+    if (typeof value === "string") {
+      const asEnum = enumValue(value);
+      return asEnum === void 0 ? bridge.setString(this.handle, path, value) : bridge.setInt(this.handle, path, asEnum);
+    }
+    if (value instanceof _MassifObject) {
+      return bridge.setObject(this.handle, path, value.handle);
+    }
+    return bridge.setString(this.handle, path, JSON.stringify(value));
+  }
+  /**
+   * Applies several properties in ONE crossing.
+   *
+   * `set` per key is one JNI or JSI call each, and configuring a layer writes a dozen. The
+   * facade takes the whole object as JSON, which is the shape a spec already has.
+   *
+   * A key whose value is another object - a handle or an inline spec - cannot be JSON, so those
+   * go one by one as before. So does everything, on an SDK built before `setAll`.
+   */
+  apply(values) {
+    const setAll = bridge.setAll;
+    const batched = {};
+    const single = [];
+    for (const key of Object.keys(values)) {
+      const value = values[key];
+      if (!setAll || value instanceof _MassifObject || isSpec(value) || resolvePath(this.className, key)?.code === "o") {
+        single.push(key);
+      } else {
+        batched[key] = value;
+      }
+    }
+    if (setAll && Object.keys(batched).length) {
+      const result = setAll(this.handle, JSON.stringify(batched), "");
+      if (result !== Result.OK) {
+        single.unshift(...Object.keys(batched));
+      }
+    }
+    for (const key of single) {
+      this.set(key, values[key]);
+    }
+    return this;
+  }
+  getPos(path, projection) {
+    const json = bridge.getPos(this.handle, path, projection ?? "");
+    return json ? JSON.parse(json) : null;
+  }
+  /** A scope over an object property, so its own properties read short. */
+  group(path) {
+    const info = resolvePath(this.className, path);
+    if (!info || info.code !== "o") {
+      throw new MassifApiError(`${this.className}.${path} is not an object property`);
+    }
+    return new PropertyGroup(this, path, info.arg);
+  }
+  /**
+   * The object an object property points at, as an object the CALLER OWNS - `destroy()` it.
+   *
+   * `group` reads THROUGH a child; this hands it over, which is what SHARING one needs: an
+   * overlay drawing the base map's tiles with a different style points at that source rather
+   * than building a second one over the same file.
+   *
+   * Null when the property is empty.
+   */
+  child(path) {
+    const info = resolvePath(this.className, path);
+    if (!info || info.code !== "o") {
+      throw new MassifApiError(`${this.className}.${path} is not an object property`);
+    }
+    const handle = bridge.getObject(this.handle, path);
+    return handle ? new _MassifObject(handle, info.arg) : null;
+  }
+  // --- methods ------------------------------------------------------------------------------
+  /**
+   * Runs a method. The path may traverse object properties, so
+   * `layer.call('tileDecoder.setStyleParameter', 'buildings', 'false')` reaches the decoder
+   * without registering it under an id of its own.
+   *
+   * A result that is an object is handed back as a `MassifObject` the CALLER OWNS - call
+   * `destroy()` on it, or it stays registered. Everything else is copied out already.
+   */
+  call(method, ...args) {
+    return this.invoke(method, args);
+  }
+  /**
+   * The untyped form of `call`, for the named wrappers below and in the subclasses.
+   *
+   * They know which class declares the method they are calling; `call`'s generic does not,
+   * because `C` is whatever the caller parameterised the object with.
+   */
+  invoke(method, args) {
+    const info = resolveMethod(this.className, method);
+    let result;
+    try {
+      result = bridge.call(this.handle, method, argsJson(args));
+    } catch (e) {
+      throw new MassifApiError(`${this.className}.${method}: ${e?.message ?? e}`);
+    }
+    return this.readResult(result, info?.code, info?.arg, true);
+  }
+  readResult(handle, code, cls, owned) {
+    if (!handle) {
+      return void 0;
+    }
+    try {
+      switch (code) {
+        case "v":
+          return void 0;
+        case "b":
+          return bridge.getBool(handle, "", false);
+        case "i":
+          return bridge.getInt(handle, "", 0);
+        case "f":
+          return bridge.getFloat(handle, "", 0);
+        case "s":
+          return bridge.getString(handle, "");
+        case "d":
+          return bridge.getDoubles(handle);
+        case "o": {
+          if (!cls) {
+            throw new MassifApiError("an object result with no class - regenerate the typings with `npm run typings.api`");
+          }
+          owned = false;
+          return new _MassifObject(handle, cls);
+        }
+        default:
+          return parseJson(bridge.getString(handle, ""));
+      }
+    } finally {
+      if (owned) {
+        bridge.destroy(handle);
+      }
+    }
+  }
+  /**
+   * The same on a worker, with the result delivered as an event the promise resolves from.
+   *
+   * `extract` runs INSIDE the delivery, which is the only place an object result is alive - the
+   * facade frees the payload once the handlers have run. Read what you need out of it:
+   *
+   * ```ts
+   * const bytes = await source.callAsync('loadTile', [[8467, 5852, 14]], (tile) => tile.getData('data'));
+   * ```
+   *
+   * A scalar or a flat array is copied out already, so `extract` can be left off for those.
+   */
+  callAsync(method, args, extract) {
+    const info = resolveMethod(this.className, method);
+    if (info?.code === "o" && !extract) {
+      throw new MassifApiError(`${this.className}.${String(method)} returns an object - pass an extract function, it runs while the result is alive`);
+    }
+    const event = `${String(method)}.done.${nextCallId()}`;
+    let call = 0;
+    let subscription;
+    const promise = new Promise((resolve, reject) => {
+      subscription = this.subscribeRaw(event, (payload) => {
+        subscription?.remove();
+        if (!payload) {
+          reject(new MassifApiError(`${this.className}.${String(method)} failed`));
+          return false;
+        }
+        try {
+          const value = info?.code === "o" || extract ? new _MassifObject(payload, info?.arg ?? this.className) : null;
+          resolve(extract ? extract(value) : this.readResult(payload, info?.code, info?.arg, false));
+        } catch (e) {
+          reject(e);
+        }
+        return false;
+      });
+      try {
+        call = bridge.callAsync(this.handle, method, argsJson(args), event);
+      } catch (e) {
+        subscription?.remove();
+        reject(new MassifApiError(`${this.className}.${String(method)}: ${e?.message ?? e}`));
+      }
+    });
+    promise.cancel = () => {
+      const cancelled = call ? bridge.cancelCall(call) : false;
+      subscription?.remove();
+      return cancelled;
+    };
+    return promise;
+  }
+  /** Cancels every queued or running async call on this object. */
+  cancelCalls() {
+    return bridge.cancelCalls(this.handle);
+  }
+  collect(map, options = {}) {
+    const countPath = options.countPath ?? "featureCount";
+    const method = options.method ?? "getFeature";
+    const count = bridge.getInt(this.handle, countPath, 0);
+    const out = [];
+    for (let i = 0; i < count; i++) {
+      const element = this.invoke(method, [i]);
+      if (!element) {
+        continue;
+      }
+      try {
+        out.push(map(element, i));
+      } finally {
+        element.destroy();
+      }
+    }
+    return out;
+  }
+  /**
+   * Anything, as JSON.
+   *
+   * The escape hatch for a path the tables cannot type - a key inside a feature's free-form
+   * properties, or a class more derived than the one this object was wrapped as.
+   */
+  json(path = "") {
+    return parseJson(bridge.getString(this.handle, path));
+  }
+  /** A blob, without turning it into a string. An empty path means the handle IS the blob. */
+  getData(path = "") {
+    return bridge.getData(this.handle, path);
+  }
+  /** A bulk numeric result - a route's path, an elevation profile - flat and in one crossing. */
+  getDoubles() {
+    return bridge.getDoubles(this.handle);
+  }
+  // --- events -------------------------------------------------------------------------------
+  /** The delivery options every later subscription on this object starts from. */
+  eventOptions(options) {
+    this.mDefaults = { ...this.mDefaults, ...options };
+    return this;
+  }
+  /** Every facade event this object answers to, its own and its bases'. */
+  get events() {
+    return eventNames(this.className);
+  }
+  /**
+   * Subscribes with options of its own, and hands back the subscription to remove.
+   *
+   * `on` is the Observable form and covers most cases; this is for a handler that needs a
+   * different projection or delivery from the object's default.
+   */
+  subscribe(event, handler, options) {
+    const consumable = this.consumes(event);
+    return this.subscribeRaw(event, (payload, snapshot) => {
+      const data = this.eventData(event, payload, consumable, snapshot);
+      handler(data);
+      warnIfIgnored(data, consumable, event);
+      return consumable && data.consumed;
+    }, options);
+  }
+  /** Whether `consumed` will be honoured for this subscription. */
+  consumes(event) {
+    return bridge.canConsume && !!findEvent(this.className, event)?.consume;
+  }
+  subscribeRaw(event, handler, options) {
+    requireApi();
+    this.beforeSubscribe(event);
+    const merged = { ...this.mDefaults, ...options };
+    const throttle = merged.throttle ?? 0;
+    const debounce = merged.debounce ?? 0;
+    const consumable = this.consumes(event);
+    if (debounce && consumable) {
+      throw new MassifApiError(`${event} is consumable, so it cannot be debounced - the SDK is waiting for the answer now, not in ${debounce} ms`);
+    }
+    let last = 0;
+    let timer = null;
+    const deliver = (payload) => {
+      if (throttle) {
+        const now = Date.now();
+        if (now - last < throttle) {
+          return false;
+        }
+        last = now;
+      }
+      if (debounce) {
+        const snapshot = payload ? parseJson(bridge.getString(payload, "")) : null;
+        if (timer) {
+          clearTimeout(timer);
+        }
+        timer = setTimeout(() => {
+          timer = null;
+          try {
+            handler(0, snapshot);
+          } catch (error) {
+            console.error(`MassifMaps: debounced handler for '${event}' threw`, error);
+          }
+        }, debounce);
+        return false;
+      }
+      return handler(payload);
+    };
+    const id = bridge.on(this.handle, event, (_target, _event, payload) => {
+      try {
+        return deliver(payload);
+      } catch (error) {
+        console.error(`MassifMaps: handler for '${event}' threw`, error);
+        return false;
+      }
+    }, DELIVERY_ORIGIN, false, merged.projection ?? "", consumable);
+    if (!id) {
+      throw new MassifApiError(`could not subscribe to ${event} on ${this.className} - a stale handle, or an unknown projection`);
+    }
+    const subscription = new Subscription(id);
+    if (debounce) {
+      subscription.onRemove(() => {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      });
+    }
+    return subscription;
+  }
+  /** Hook for a subclass that has to install a native listener before the first subscription. */
+  beforeSubscribe(event) {
+  }
+  eventData(event, payload, consumable, snapshot) {
+    const info = findEvent(this.className, event);
+    const fromSnapshot = snapshot !== void 0 && snapshot !== null;
+    let object;
+    const payloadObject = () => {
+      if (object === void 0) {
+        object = payload && info?.payload ? new _MassifObject(payload, info.payload) : null;
+      }
+      return object;
+    };
+    const proto = (payload || fromSnapshot) && info?.payload ? payloadProto(info.payload) : null;
+    const data = Object.assign(proto ? Object.create(proto) : {}, {
+      eventName: event,
+      object: this,
+      consumed: false,
+      consumable,
+      get: (path) => {
+        if (fromSnapshot) {
+          return path ? snapshot[path] : snapshot;
+        }
+        const target = payloadObject();
+        if (!target) {
+          throw new MassifApiError(`${event} carries no payload`);
+        }
+        return target.get(path);
+      },
+      getPos: (path, projection) => {
+        if (fromSnapshot) {
+          return snapshot[path] ?? null;
+        }
+        const target = payloadObject();
+        return target ? target.getPos(path, projection) : null;
+      }
+    });
+    Object.defineProperty(data, "payload", { enumerable: true, configurable: true, get: payloadObject });
+    return data;
+  }
+  /**
+   * Observable's `on`, with the event name and the payload typed.
+   *
+   * ```ts
+   * layer.on('vectortile.clicked', (e) => console.log(e.get('featureLayerName')));
+   * ```
+   *
+   * Deliberately NOT widened to `string`: a typo in an event name is the failure this whole
+   * layer exists to catch, and `addEventListener` is still there for a name of your own.
+   */
+  on(event, callback, thisArg) {
+    super.on(event, callback, thisArg);
+  }
+  once(event, callback, thisArg) {
+    super.once(event, callback, thisArg);
+  }
+  off(event, callback, thisArg) {
+    super.off(event, callback, thisArg);
+  }
+  /**
+   * Observable's own hook. A facade event takes its native subscription here, on the first
+   * handler, so nothing is listening that nobody asked for.
+   */
+  addEventListener(eventNames2, callback, thisArg, ...rest) {
+    super.addEventListener(eventNames2, callback, thisArg, ...rest);
+    for (const name of splitEvents(eventNames2)) {
+      if (!this.mSubscriptions[name] && findEvent(this.className, name) !== null) {
+        const consumable = this.consumes(name);
+        this.mSubscriptions[name] = this.subscribeRaw(name, (payload, snapshot) => {
+          const data = this.eventData(name, payload, consumable, snapshot);
+          this.notify(data);
+          warnIfIgnored(data, consumable, name);
+          return consumable && data.consumed;
+        });
+      }
+    }
+  }
+  removeEventListener(eventNames2, callback, thisArg) {
+    super.removeEventListener(eventNames2, callback, thisArg);
+    for (const name of splitEvents(eventNames2)) {
+      if (this.mSubscriptions[name] && !this.hasListeners(name)) {
+        this.mSubscriptions[name].remove();
+        delete this.mSubscriptions[name];
+      }
+    }
+  }
+  // --- lifetime -----------------------------------------------------------------------------
+  /**
+   * Drops the id and the context's reference to the object. Subscriptions and pending async
+   * calls die with it, which is what stops a handler running against a freed object.
+   */
+  destroy() {
+    if (this.mDestroyed) {
+      return false;
+    }
+    this.mDestroyed = true;
+    for (const name of Object.keys(this.mSubscriptions)) {
+      this.mSubscriptions[name].remove();
+    }
+    this.mSubscriptions = {};
+    return bridge.destroy(this.handle);
+  }
+  toString() {
+    return `${this.constructor.name}(${this.className}#${this.handle}${this.id ? ` "${this.id}"` : ""})`;
+  }
+};
+function splitEvents(eventNames2) {
+  return eventNames2.split(",").map((n) => n.trim()).filter(Boolean);
+}
+var callId = 0;
+function nextCallId() {
+  return ++callId;
+}
+var warnedConsume = {};
+function warnIfIgnored(data, consumable, event) {
+  if (!data.consumed || consumable || warnedConsume[event]) {
+    return;
+  }
+  warnedConsume[event] = true;
+  const why = bridge.canConsume ? "it is not a consumable event" : "this SDK's MassifApi.on does not take the consume flag";
+  console.warn(`massif: a handler consumed ${event} but nothing will act on it - ${why}`);
+}
+function resultName(result) {
+  for (const name of Object.keys(Result)) {
+    if (Result[name] === result) {
+      return name;
+    }
+  }
+  return `result ${result}`;
+}
+var MassifLayer = class extends MassifObject {
+  constructor() {
+    super(...arguments);
+    this.mBridged = {};
+  }
+  beforeSubscribe(event) {
+    if (this.mBridged[event] || !this.id) {
+      return;
+    }
+    const native = bridge.getNativeLayer(this.id);
+    if (!native) {
+      return;
+    }
+    if (event === "vectortile.clicked") {
+      bridge.attachVectorTileEvents(native, this.handle);
+    } else if (event === "vectorelement.clicked") {
+      bridge.attachVectorElementEvents(native, this.handle);
+    } else if (event === "celestial.clicked" || event === "sky.clicked") {
+      if (!this.mBridged["celestial.clicked"] && !this.mBridged["sky.clicked"]) {
+        bridge.attachCelestialEvents(native, this.handle);
+      }
+    } else {
+      return;
+    }
+    this.mBridged[event] = true;
+  }
+  /** The native layer, to hand back to the object API - by id, or by handle when it has none. */
+  get native() {
+    return this.id ? bridge.getNativeLayer(this.id) : bridge.getNativeLayerByHandle(this.handle);
+  }
+  opacity(value) {
+    return value === void 0 ? this.get("opacity") : this.set("opacity", value);
+  }
+  visible(value) {
+    return value === void 0 ? this.get("visible") : this.set("visible", value);
+  }
+  zoomRange(range) {
+    return range === void 0 ? this.get("visibleZoomRange") : this.set("visibleZoomRange", range);
+  }
+  // --- placement ----------------------------------------------------------------------------
+  /** Moves the layer within the map's stack. 0 is the bottom. */
+  moveTo(index) {
+    this.requireMap().layers().insert(index, this);
+    return this;
+  }
+  /** Takes it off the map. The object stays registered until it is destroyed. */
+  detach() {
+    this.requireMap().layers().remove(this);
+    return this;
+  }
+  // --- the layer methods, by name -----------------------------------------------------------
+  refresh() {
+    this.invoke("refresh", []);
+    return this;
+  }
+  /**
+   * The layer's data source, as an object the CALLER OWNS.
+   *
+   * `child('dataSource')` typed as a source, so `.native` is there: handing the base map's tiles
+   * to the app's own native code is the one thing the facade cannot express, and this is the
+   * escape hatch for it.
+   */
+  source() {
+    const child = this.child("dataSource");
+    return child ? new MassifSource(child.handle, child.className) : null;
+  }
+  /** Drops this layer's tiles. `all` includes the preloading caches, not just the visible set. */
+  clearTileCaches(all = false) {
+    this.invoke("clearTileCaches", [all]);
+    return this;
+  }
+  /**
+   * Elevations under a set of positions, flat and in one crossing - a profile over a track is
+   * thousands of numbers and neither JSON nor a per-element proxy is an acceptable way to move
+   * them. Only a hillshade layer answers; anything else gives an empty array.
+   */
+  elevations(positions) {
+    try {
+      return this.invoke("getElevations", [positions.map(toPosition)]);
+    } catch (e) {
+      return [];
+    }
+  }
+  // --- clicks, by name ----------------------------------------------------------------------
+  // The payload is named OUTRIGHT rather than as MassifEventData<C, EventName<C>>: each of
+  // these subscribes to ONE event, and a layer whose class is not narrowed - the common case,
+  // since `layers().get(i)` and `child('dataSource')` hand back a bare `MassifLayer` - resolved
+  // that to MassifEventData<any, string>, which has no payload fields on it at all.
+  /** `on('vectortile.clicked', …)`, named. Set `e.consumed` to claim the click. */
+  onFeatureClick(handler, options) {
+    return this.subscribe("vectortile.clicked", handler, options);
+  }
+  /** `on('vectorelement.clicked', …)`, named - a marker or a popup the app added. */
+  onElementClick(handler, options) {
+    return this.subscribe("vectorelement.clicked", handler, options);
+  }
+  /** `on('celestial.clicked', …)`, named - an object of a celestial layer. Set `e.consumed` to claim the click. */
+  onCelestialClick(handler, options) {
+    return this.subscribe("celestial.clicked", handler, options);
+  }
+  /** `on('sky.clicked', …)`, named - a tap on empty sky: it hit nothing, and has no ground position for `map.clicked`. */
+  onSkyClick(handler, options) {
+    return this.subscribe("sky.clicked", handler, options);
+  }
+  requireMap() {
+    if (!this.map) {
+      throw new MassifApiError(`layer is not attached to a map: ${this}`);
+    }
+    return this.map;
+  }
+};
+var MassifSource = class extends MassifObject {
+  /** The native source, to hand back to the object API - by id, or by handle when it has none. */
+  get native() {
+    return this.id ? bridge.getNativeSource(this.id) : bridge.getNativeSourceByHandle(this.handle);
+  }
+  /**
+   * One tile, BLOCKING - an HTTP source fetches it on the calling thread.
+   * `loadTileAsync` is the one to use from the UI thread.
+   */
+  loadTile(tile) {
+    const result = this.invoke("loadTile", [tile]);
+    try {
+      return result ? result.getData("data") : null;
+    } finally {
+      result?.destroy();
+    }
+  }
+  /**
+   * Declares a layer inside a `geojson` source and returns its index.
+   *
+   * The source re-tiles whatever it is given, so replacing the document later is one
+   * `setGeoJSON` rather than rebuilding the layer above it.
+   */
+  createLayer(name) {
+    return this.invoke("createLayer", [name]);
+  }
+  /**
+   * Replaces a declared layer's document. The tiles are rebuilt on the tile thread, so this
+   * costs the re-encode rather than a layer rebuild.
+   *
+   * A string is parsed here rather than passed through: the argument crosses as JSON already,
+   * and sending text would arrive as a string-valued argument instead of a document.
+   */
+  setGeoJSON(layer, geojson) {
+    this.invoke("setLayerGeoJSON", [layer, typeof geojson === "string" ? JSON.parse(geojson) : geojson]);
+    return this;
+  }
+  /** Drops a declared layer and everything in it. */
+  deleteLayer(layer) {
+    this.invoke("deleteLayer", [layer]);
+    return this;
+  }
+  /**
+   * One feature at a time, for an app that edits what it is showing.
+   *
+   * `setGeoJSON` re-encodes and re-tiles the whole document; on a few hundred saved routes that is
+   * the difference between instant and not. `update` matches on the feature's own `id`.
+   */
+  addFeature(layer, feature) {
+    this.invoke("addFeature", [layer, feature]);
+    return this;
+  }
+  updateFeature(layer, feature) {
+    this.invoke("updateFeature", [layer, feature]);
+    return this;
+  }
+  removeFeature(layer, id) {
+    this.invoke("removeFeature", [layer, id]);
+    return this;
+  }
+  /** The same on a worker. The bytes are copied out while the result is still alive. */
+  loadTileAsync(tile) {
+    return this.callAsync("loadTile", [tile], ((result) => result.getData("data")));
+  }
+};
+var WRAPPERS = {
+  layer: MassifLayer,
+  source: MassifSource
+};
+function wrapperFor(kind) {
+  return WRAPPERS[kind] ?? MassifObject;
+}
+function create(kind, id, spec, className) {
+  requireApi();
+  let handle;
+  try {
+    handle = bridge.create(kind, id, JSON.stringify(spec));
+  } catch (e) {
+    throw new MassifApiError(`create ${kind}:${id}: ${e?.message ?? e}`);
+  }
+  if (!handle) {
+    throw new MassifApiError(`create ${kind}:${id} returned no handle`);
+  }
+  const resolved = className ?? classOfSpec(kind, spec.type) ?? "massif::Layer";
+  return new (wrapperFor(kind))(handle, resolved, id);
+}
+function createLayer(id, spec) {
+  return create("layer", id, spec);
+}
+function createSource(id, spec) {
+  return create("source", id, spec);
+}
+function find(kind, id, className) {
+  requireApi();
+  const handle = bridge.findObject(kind, id);
+  if (!handle) {
+    return null;
+  }
+  return new (wrapperFor(kind))(handle, className, id);
+}
+function destroy(kind, id) {
+  return bridge.available ? bridge.unregisterObject(kind, id) : false;
+}
+function wrap(handle, className, id) {
+  return new MassifObject(handle, className, id);
+}
+function wrapLayer(handle, className, id) {
+  return new MassifLayer(handle, className, id);
+}
+function adoptLayer(id, nativeLayer, className) {
+  requireApi();
+  const handle = bridge.adoptLayer("layer", id, nativeLayer);
+  if (!handle) {
+    throw new MassifApiError(`could not adopt layer "${id}" - the id is taken, or the class is not a wrapped one`);
+  }
+  return new MassifLayer(handle, resolveNativeClass(nativeLayer, className, "massif::Layer"), id);
+}
+function adoptSource(id, nativeSource, className) {
+  requireApi();
+  const handle = bridge.adoptSource("source", id, nativeSource);
+  if (!handle) {
+    throw new MassifApiError(`could not adopt source "${id}" - the id is taken, or the class is not a wrapped one`);
+  }
+  return new MassifSource(handle, resolveNativeClass(nativeSource, className, "massif::TileDataSource"), id);
+}
+function adoptAssets(id, nativeAssets, className) {
+  requireApi();
+  const handle = bridge.adoptAssets("assets", id, nativeAssets);
+  if (!handle) {
+    throw new MassifApiError(`could not adopt assets "${id}" - the id is taken, or the class is not a wrapped one`);
+  }
+  return new MassifObject(handle, resolveNativeClass(nativeAssets, className, "massif::AssetPackage"), id);
+}
+function resolveNativeClass(nativeObject, given, fallback) {
+  if (given) {
+    if (!isKnownClass(given)) {
+      throw new MassifApiError(`${given} is not a class the typings know - regenerate them with \`npm run typings.api\``);
+    }
+    return given;
+  }
+  return classOfShortName(bridge.nativeShortClassName(nativeObject)) ?? fallback;
+}
+var MassifElements = class {
+  constructor(map, id, sourceSpec) {
+    this.map = map;
+    this.id = id;
+    this.sourceSpec = sourceSpec;
+    this.mCounter = 0;
+  }
+  /**
+   * Adds an element - a `marker`, a `balloon`. The spec's `style` either names one registered
+   * earlier or carries it inline, which is what most apps write.
+   *
+   * @returns the element, for `remove`. Its properties read and write by path like any other.
+   */
+  add(spec) {
+    const element = this.map.object("element", `${this.id}.el${++this.mCounter}`, spec);
+    this.built().source.call("add", element.handle);
+    return element;
+  }
+  /**
+   * Registers a style under an id so many elements share ONE style object - which is what
+   * matters once there are thousands of them.
+   */
+  style(styleId, spec) {
+    return this.map.object("elementstyle", `${this.id}.${styleId}`, spec);
+  }
+  /** Removes one element. It stays registered until it is destroyed. */
+  remove(element) {
+    return this.mSource && element ? this.mSource.call("remove", element.handle) : false;
+  }
+  /** Removes every element this has added. */
+  clear() {
+    this.mSource?.call("clear");
+    return this;
+  }
+  /**
+   * Clicks on the elements themselves, with the element's position on the payload.
+   *
+   * Set `e.consumed` in the handler to claim the tap, which is what an app wants whenever
+   * "tap a marker" and "tap the map" mean different things - otherwise one tap does both.
+   */
+  onClick(handler, options) {
+    return this.built().layer.subscribe("vectorelement.clicked", handler, options);
+  }
+  /** The layer they are drawn on, for opacity, visibility and ordering. */
+  layer() {
+    return this.built().layer;
+  }
+  /** The source holding them, for anything else a local source reaches. */
+  source() {
+    return this.built().source;
+  }
+  /** Built on first use, so a map that never adds an element pays nothing. */
+  built() {
+    if (!this.mSource || !this.mLayer) {
+      this.mSource = this.map.object("source", this.id, this.sourceSpec ?? { type: "local", projection: { type: "EPSG:4326" } });
+      this.mLayer = this.map.addLayer(this.id, { type: "elements", source: this.id });
+    }
+    return { source: this.mSource, layer: this.mLayer };
+  }
+};
+function log() {
+  return find("static", "Log", "massif::Log");
+}
+var MapCamera = class {
+  /**
+   * @param view The ADOPTED map view - every call below is a facade call on its handle.
+   * @param size The view's pixel size, for the fitBounds default. A size is a property of the
+   *        VIEW, not of the camera, and BaseMapView does not expose one - so the map, which
+   *        holds the NativeScript view, measures it.
+   */
+  constructor(view, size) {
+    this.view = view;
+    this.size = size;
+    this.mDuration = 0;
+  }
+  /** Milliseconds every later move animates over. 0 is immediate, and is the default. */
+  animate(ms) {
+    this.mDuration = ms;
+    return this;
+  }
+  /** Seconds, which is what the facade takes; the public API is milliseconds. */
+  take(duration) {
+    const ms = duration ?? this.mDuration;
+    this.mDuration = 0;
+    return ms / 1e3;
+  }
+  position(value) {
+    if (value === void 0) {
+      return this.view.getPos("focusPos");
+    }
+    return this.moveTo(value);
+  }
+  /** Where the camera IS, not what it looks at - kilometres apart at a low tilt. */
+  eyePosition() {
+    return this.view.getPos("cameraPos");
+  }
+  zoom(value, target) {
+    if (value === void 0) {
+      return this.view.get("zoom");
+    }
+    return this.moveTo(target ?? this.position(), { zoom: value });
+  }
+  rotation(degrees) {
+    if (degrees === void 0) {
+      return this.view.get("rotation");
+    }
+    return this.moveTo(this.position(), { rotation: degrees });
+  }
+  tilt(degrees) {
+    if (degrees === void 0) {
+      return this.view.get("tilt");
+    }
+    return this.moveTo(this.position(), { tilt: degrees });
+  }
+  /**
+   * Position, zoom, rotation and tilt in ONE move.
+   *
+   * Four separate setters animate independently and visibly fight each other, which is the
+   * whole reason this exists rather than a chain of the accessors above. With no duration it
+   * is immediate, and works before the map has drawn - which is when a screen usually points
+   * its camera.
+   */
+  moveTo(position, options = {}) {
+    const pos = toPosition(position);
+    const zoom = options.zoom ?? this.zoom();
+    const rotation = options.rotation ?? this.rotation();
+    const tilt = options.tilt ?? this.tilt();
+    const seconds = this.take(options.duration);
+    if (seconds > 0) {
+      this.view.call("flyTo", pos, zoom, rotation, tilt, options.climbHeight ?? 0, seconds, "");
+    } else {
+      this.view.call("moveTo", pos, zoom, rotation, tilt);
+    }
+    return this;
+  }
+  /** Frames a `[min, max]` box. `screen` defaults to the whole view. */
+  fitBounds(bounds, options = {}) {
+    const { width, height } = this.size();
+    const screen = options.screen ? [[options.screen.min.x, options.screen.min.y], [options.screen.max.x, options.screen.max.y]] : [[0, 0], [width, height]];
+    this.view.call("fitBounds", [toPosition(bounds[0]), toPosition(bounds[1])], screen, !!options.integerZoom, !!options.resetRotation, !!options.resetTilt, this.take(options.duration));
+    return this;
+  }
+  /** Whether a flight is running. */
+  isMoving() {
+    return this.view.get("flightActive");
+  }
+  /** 0 to 1 through the current flight, or -1 when none is running. */
+  progress() {
+    return this.view.get("flightProgress");
+  }
+  stop() {
+    this.view.call("stopFlight");
+    return this;
+  }
+  /** Screen point to map position. */
+  screenToMap(x, y) {
+    return this.view.call("screenToMap", x, y);
+  }
+  mapToScreen(position) {
+    const point = this.view.call("mapToScreen", toPosition(position));
+    return { x: point[0], y: point[1] };
+  }
+  /**
+   * What the view currently covers, as `[min, max]`.
+   *
+   * The two screen corners unprojected, which is what the answer is: there is no "bounds"
+   * property, because a tilted or rotated camera does not have one - this is the axis-aligned box
+   * around what it shows.
+   */
+  bounds() {
+    const { height, width } = this.size();
+    const first = this.screenToMap(0, 0);
+    const second = this.screenToMap(width, height);
+    return [
+      [Math.min(first[0], second[0]), Math.min(first[1], second[1])],
+      [Math.max(first[0], second[0]), Math.max(first[1], second[1])]
+    ];
+  }
+};
+var MapLayers = class extends MassifObject {
+  constructor(handle, id) {
+    super(handle, "massif::Layers", id);
+  }
+  /** How many layers the map is drawing, including any the object API put there. */
+  count() {
+    return this.get("count");
+  }
+  /** Appends. 0 is the bottom, so this puts the layer on top of everything else. */
+  add(layer) {
+    this.call("add", handleOf(layer));
+    return this;
+  }
+  /** Puts the layer at `index`, moving everything at or above it up. */
+  insert(index, layer) {
+    this.call("insert", index, handleOf(layer));
+    return this;
+  }
+  /**
+   * Replaces the layer at `index` - what a rebuilt decoder needs, keeping the position.
+   *
+   * Not `set`: that is the property writer every object has, and a two-argument overload of it
+   * would make every `layers.set('count', …)` typo compile.
+   */
+  replace(index, layer) {
+    this.call("set", index, handleOf(layer));
+    return this;
+  }
+  /** The layer at `index`, as a bare `Layer` - the list does not record what each one is. */
+  at(index) {
+    const layer = this.call("get", index);
+    return layer ? new MassifLayer(layer.handle, "massif::Layer") : null;
+  }
+  remove(layer) {
+    return this.call("remove", handleOf(layer));
+  }
+  /** Empties the stack. */
+  clear() {
+    this.call("clear");
+    return this;
+  }
+};
+var MassifMap = class extends MassifObject {
+  constructor(handle, id, view) {
+    super(handle, "massif::Options", id);
+    this.view = view;
+    this.mLayerById = {};
+    this.mOwned = [];
+  }
+  /**
+   * The map's layer list, ordered.
+   *
+   * `addLayer` covers the common case; this is for an app whose stack has an order of its own -
+   * base map, then overlays, then its own markers - and so places a layer at an index, swaps one
+   * in place when its decoder is rebuilt, or counts what is there.
+   */
+  layers() {
+    if (!this.mLayers) {
+      const id = `${this.id}:layers`;
+      let handle = bridge.findObject("layers", id);
+      if (!handle) {
+        handle = bridge.adoptLayers("layers", id, this.view.mapView.getLayers());
+        if (!handle) {
+          throw new MassifApiError(`could not register the layer list of "${this.id}" under "${id}"`);
+        }
+        this.mOwned.push(["layers", id]);
+      }
+      this.mLayers = new MapLayers(handle, id);
+    }
+    return this.mLayers;
+  }
+  /**
+   * Builds a layer from a spec and puts it on the map.
+   *
+   * ```ts
+   * map.addLayer('base', {
+   *     type: 'vector',
+   *     source: { type: 'http', maxZoom: 14, url: 'https://…/{z}/{x}/{y}.pbf' },
+   *     style: { type: 'mbvt', project: { type: 'project', assets: { type: 'dir', path: '…' }, name: 'osm' } }
+   * });
+   * ```
+   */
+  addLayer(id, spec) {
+    return this.add(this.object("layer", id, spec));
+  }
+  /**
+   * Builds a layer this map OWNS but does not place it.
+   *
+   * For an app whose stack has an order of its own: it works out the index from the layers it has
+   * already added, then calls `add(layer, index)` or `layers().insert(...)`. `addLayer` is the
+   * one-liner for everything else.
+   */
+  buildLayer(id, spec) {
+    const layer = this.object("layer", id, spec);
+    layer.map = this;
+    return layer;
+  }
+  /** Puts a layer built or adopted elsewhere on the map, optionally at a given index. */
+  add(layer, index) {
+    const layers = this.layers();
+    if (index === void 0) {
+      layers.add(layer);
+    } else {
+      layers.insert(index, layer);
+    }
+    layer.map = this;
+    if (layer.id) {
+      this.mLayerById[layer.id] = layer;
+    }
+    return layer;
+  }
+  /** Takes a layer off the map. The layer stays registered until it is destroyed. */
+  removeLayer(layer) {
+    if (layer instanceof MassifLayer && layer.id) {
+      delete this.mLayerById[layer.id];
+    }
+    return this.layers().remove(layer);
+  }
+  /** A layer this map added or adopted, by the id it was given. */
+  layer(id) {
+    return this.mLayerById[id] ?? null;
+  }
+  /** How many layers the map is drawing, including any the object API put there. */
+  layerCount() {
+    return this.layers().count();
+  }
+  /** Adopts a layer built with the object API, and puts it under this map. */
+  adopt(id, nativeLayer, className) {
+    const layer = adoptLayer(id, nativeLayer, className);
+    layer.map = this;
+    this.mLayerById[id] = layer;
+    return layer;
+  }
+  object(kind, id, spec, className) {
+    const built = create(kind, id, spec, className);
+    this.mOwned.push([kind, id]);
+    return built;
+  }
+  /** A source this map owns. */
+  source(id, spec) {
+    return this.object("source", id, spec);
+  }
+  /**
+   * A style this map owns.
+   *
+   * Worth an id whenever the app talks to it afterwards - a style parameter, a theme switch -
+   * because a layer's style property cannot be read back as a handle.
+   */
+  style(id, spec) {
+    return this.object("style", id, spec);
+  }
+  // --- markers and popups ---------------------------------------------------------------------
+  /**
+   * The map's own markers and popups, on a layer built the first time this is called.
+   *
+   * `sourceSpec` is how a map that does NOT work in lon/lat places its markers correctly; only
+   * the first call builds, later ones return what it built.
+   */
+  elements(sourceSpec) {
+    if (!this.mElements) {
+      this.mElements = new MassifElements(this, `${this.id}.elements`, sourceSpec);
+    }
+    return this.mElements;
+  }
+  /** Adds a marker. The spec carries its position AND its style, inline or by id. */
+  addMarker(spec) {
+    return this.elements().add(spec);
+  }
+  /** The same for a balloon popup - a title and a body anchored to a position. */
+  addPopup(spec) {
+    return this.elements().add(spec);
+  }
+  /**
+   * Releases the map's registration and every id it built - layers, sources, styles, elements.
+   *
+   * Not the view: the object API's map keeps working, which is the point of a facade that can
+   * be adopted a piece at a time.
+   */
+  destroy() {
+    for (let i = this.mOwned.length - 1; i >= 0; i--) {
+      destroy(this.mOwned[i][0], this.mOwned[i][1]);
+    }
+    this.mOwned.length = 0;
+    this.mElements = void 0;
+    this.mCamera = void 0;
+    return super.destroy();
+  }
+  /**
+   * The view's size in pixels.
+   *
+   * A property of the VIEW, not of the map, but every caller that needs it has the map: framing a
+   * route, working out how many metres a screen width covers.
+   */
+  size() {
+    return { width: this.view.getMeasuredWidth?.() ?? 0, height: this.view.getMeasuredHeight?.() ?? 0 };
+  }
+  /**
+   * A screenshot of the map.
+   *
+   * The one thing on this class that is not a facade call: reading the framebuffer is platform
+   * code, and there is no verb for it. `wait` holds the capture until the tiles have settled.
+   */
+  capture(wait = false) {
+    if (!this.view.captureRendering) {
+      throw new MassifApiError("this map view cannot capture its rendering");
+    }
+    return this.view.captureRendering(wait);
+  }
+  /**
+   * Asks for a frame.
+   *
+   * Rarely needed: the SDK redraws when a property that changes the picture is written. It is
+   * here for the cases where an app knows better - a change made off the UI thread, or a view
+   * that was hidden while the map moved.
+   */
+  requestRedraw() {
+    this.view.requestRedraw?.();
+    return this;
+  }
+  /** The camera. See MapCamera - a move is a flight, not a property. */
+  camera() {
+    if (!this.mCamera) {
+      const id = `${this.id}:view`;
+      let handle = bridge.findObject("view", id);
+      if (!handle) {
+        handle = bridge.adoptView("view", id, this.view.mapView.getBaseMapView());
+        if (!handle) {
+          throw new MassifApiError(`could not register the map view of "${this.id}"`);
+        }
+        this.mOwned.push(["view", id]);
+      }
+      const view = new MassifObject(handle, "massif::BaseMapView", id);
+      this.mCamera = new MapCamera(view, () => this.size());
+    }
+    return this.mCamera;
+  }
+  /**
+   * The projection every later handler's position reads default to.
+   *
+   * Shorthand for `eventOptions({ projection })`, and the one an app actually wants: ask once,
+   * then read `e.getPos('clickPos')` plainly.
+   */
+  eventProjection(name) {
+    return this.eventOptions({ projection: name });
+  }
+  // --- the map events, by name ---------------------------------------------------------------
+  onClick(handler, options) {
+    return this.subscribe("map.clicked", handler, options);
+  }
+  onMove(handler, options) {
+    return this.subscribe("map.moved", handler, options);
+  }
+  onIdle(handler, options) {
+    return this.subscribe("map.idle", handler, options);
+  }
+  onStable(handler, options) {
+    return this.subscribe("map.stable", handler, options);
+  }
+  onInteraction(handler, options) {
+    return this.subscribe("map.interaction", handler, options);
+  }
+  // --- the option groups, which is what most of an app touches -------------------------------
+  /*
+   * One accessor per options CLASS, not per option - that list is closed and does not grow with
+   * the SDK, while the properties inside them are data.
+   *
+   * With no argument they scope onto what is already there. With a spec they BUILD it first,
+   * which is what a map needs on the way in: Options starts with these properties empty, and
+   * writing through an empty one is an error rather than a silent no-op.
+   */
+  /** `fogOptions.*` - fog on the mapbox model, independent of the terrain. */
+  fog(spec) {
+    return this.optionGroup("fogOptions", "fog", spec);
+  }
+  /** `skyOptions.*` - the sky dome behind the map. */
+  sky(spec) {
+    return this.optionGroup("skyOptions", "sky", spec);
+  }
+  /** `lightOptions.*` - sun direction and colour, which the terrain shades from. */
+  light(spec) {
+    return this.optionGroup("lightOptions", "light", spec);
+  }
+  /**
+   * `terrainOptions.*` - 3D terrain from an elevation source.
+   *
+   * The elevation decoder comes from the source's own `encoding`, so nothing here names one.
+   */
+  terrain(spec) {
+    return this.optionGroup("terrainOptions", "terrain", spec);
+  }
+  optionGroup(property, type, spec) {
+    if (spec) {
+      const built = this.object("options", `${this.id}.${type}`, spec);
+      this.set(property, built.handle);
+    }
+    return this.group(property);
+  }
+};
+function attach(view, options = {}) {
+  requireApi();
+  const existing = view.facadeMap?.();
+  if (existing) {
+    const { projection: existingProjection, throttle: existingThrottle, debounce: existingDebounce } = options;
+    if (existingProjection || existingThrottle || existingDebounce) {
+      existing.eventOptions({ projection: existingProjection, throttle: existingThrottle, debounce: existingDebounce });
+      view.enableFacadeEvents?.();
+    }
+    return existing;
+  }
+  const nativeOptions = view.getOptions()?.getNative();
+  if (!nativeOptions) {
+    throw new MassifApiError("the map is not ready yet - attach from the mapReady event");
+  }
+  const id = options.id ?? "map";
+  const handle = bridge.adoptOptions("options", id, nativeOptions);
+  if (!handle) {
+    throw new MassifApiError(`could not register the map under "${id}" - the id is taken`);
+  }
+  bridge.attachMapEvents(view.mapView, handle);
+  const map = new MassifMap(handle, id, view);
+  const { projection, throttle, debounce } = options;
+  if (projection || throttle || debounce) {
+    map.eventOptions({ projection, throttle, debounce });
+  }
+  return map;
+}
+
+// ../../dist/web/bridge.mjs
+var OK = 0;
+var DELIVERY_UI = "ui";
+function createBridge(module) {
+  const fn = (name, returns, args) => module.cwrap(name, returns, args);
+  const c = {
+    ctx: fn("mm_context_default", "number", [])(),
+    create: fn("mm_create", "number", ["number", "string", "string", "string", "number"]),
+    destroy: fn("mm_destroy", "number", ["number", "string", "string"]),
+    destroyHandle: fn("mm_destroy_handle", "number", ["number", "number"]),
+    find: fn("mm_find", "number", ["number", "string", "string", "number"]),
+    valid: fn("mm_valid", "number", ["number", "number"]),
+    setBool: fn("mm_set_bool", "number", ["number", "number", "string", "number"]),
+    setDouble: fn("mm_set_double", "number", ["number", "number", "string", "number"]),
+    setString: fn("mm_set_string", "number", ["number", "number", "string", "string"]),
+    setJson: fn("mm_set_json", "number", ["number", "number", "string", "string"]),
+    setObject: fn("mm_set_object", "number", ["number", "number", "string", "number"]),
+    getObject: fn("mm_get_object", "number", ["number", "number", "string"]),
+    getBool: fn("mm_get_bool", "number", ["number", "number", "string", "number"]),
+    getDouble: fn("mm_get_double", "number", ["number", "number", "string", "number"]),
+    getString: fn("mm_get_string", "number", ["number", "number", "string", "string", "number", "number", "number"]),
+    call: fn("mm_call", "number", ["number", "number", "string", "string", "number"]),
+    callAsync: fn("mm_call_async", "number", ["number", "number", "string", "string", "string", "number"]),
+    cancelCall: fn("mm_cancel_call", "number", ["number", "number"]),
+    cancelCalls: fn("mm_cancel_calls", "number", ["number", "number", "number"]),
+    doublesCount: fn("mm_doubles_count", "number", ["number", "number", "number"]),
+    doublesCopy: fn("mm_doubles_copy", "number", ["number", "number", "number", "number", "number"]),
+    dataSize: fn("mm_data_size", "number", ["number", "number", "string", "number"]),
+    dataCopy: fn("mm_data_copy", "number", ["number", "number", "string", "number", "number", "number"]),
+    on: fn("mm_on", "number", ["number", "number", "string", "number", "number", "string", "number"]),
+    off: fn("mm_off", "number", ["number", "number"]),
+    offAll: fn("mm_off_all", "number", ["number", "number", "number"]),
+    resultName: fn("mm_result_name", "string", ["number"]),
+    adopt: fn("massifAdopt", "number", ["string", "string", "string"]),
+    attachMapEvents: fn("massifAttachMapEvents", null, ["number"]),
+    bridgeLayerClicks: fn("massifBridgeLayerClicks", "number", ["number"])
+  };
+  const ctx = c.ctx;
+  const handlers = /* @__PURE__ */ new Map();
+  const scratch = (size, body) => {
+    const pointer = module._malloc(size);
+    module.HEAPU8.fill(0, pointer, pointer + size);
+    try {
+      return body(pointer);
+    } finally {
+      module._free(pointer);
+    }
+  };
+  const unsigned = (out) => module.getValue(out, "i32") >>> 0;
+  const outInt = (body) => scratch(4, (out) => body(out) === OK ? unsigned(out) : 0);
+  const fail = (what, code) => {
+    throw new Error(`${what} failed: ${c.resultName(code)} (${code})`);
+  };
+  const readString = (handle, path, projection) => scratch(4, (needed) => {
+    if (c.getString(ctx, handle, path, projection ?? "", 0, 0, needed) !== OK) {
+      return null;
+    }
+    const size = module.getValue(needed, "i32");
+    return scratch(size + 1, (buffer) => c.getString(ctx, handle, path, projection ?? "", buffer, size + 1, needed) === OK ? module.UTF8ToString(buffer) : null);
+  });
+  const readNumber = (getter, handle, path, fallback, type) => scratch(8, (out) => getter(ctx, handle, path, out) === OK ? module.getValue(out, type) : fallback);
+  const part = (what) => ({ webPart: what });
+  return {
+    available: true,
+    canConsume: false,
+    create(kind, id, json) {
+      let code = OK;
+      const handle = scratch(4, (out) => {
+        code = c.create(ctx, kind, id, json, out);
+        return unsigned(out);
+      });
+      return code === OK ? handle : fail(`create ${kind} "${id}"`, code);
+    },
+    destroy: (handle) => c.destroyHandle(ctx, handle) === OK,
+    isValid: (handle) => c.valid(ctx, handle) === OK,
+    findObject: (kind, id) => outInt((out) => c.find(ctx, kind, id, out)),
+    unregisterObject: (kind, id) => c.destroy(ctx, kind, id) === OK,
+    // One numeric type in JavaScript; the ABI coerces a double into an int property.
+    setFloat: (handle, path, value) => c.setDouble(ctx, handle, path, value),
+    setInt: (handle, path, value) => c.setDouble(ctx, handle, path, value),
+    setBool: (handle, path, value) => c.setBool(ctx, handle, path, value ? 1 : 0),
+    setString: (handle, path, value) => c.setString(ctx, handle, path, value),
+    setObject: (handle, path, value) => c.setObject(ctx, handle, path, value),
+    setAll: (handle, json, projection) => c.setJson(ctx, handle, json, projection ?? ""),
+    getObject: (handle, path) => c.getObject(ctx, handle, path) >>> 0,
+    getFloat: (handle, path, fallback) => readNumber(c.getDouble, handle, path, fallback, "double"),
+    getInt: (handle, path, fallback) => Math.trunc(readNumber(c.getDouble, handle, path, fallback, "double")),
+    getBool: (handle, path, fallback) => !!readNumber(c.getBool, handle, path, fallback ? 1 : 0, "i32"),
+    getString: (handle, path) => readString(handle, path, ""),
+    getPos: (handle, path, projection) => readString(handle, path, projection) || null,
+    call(handle, method, argsJson2) {
+      let code = OK;
+      const result = scratch(4, (out) => {
+        code = c.call(ctx, handle, method, argsJson2, out);
+        return unsigned(out);
+      });
+      return code === OK ? result : fail(`call ${method}`, code);
+    },
+    callAsync(handle, method, argsJson2, event) {
+      let code = OK;
+      const call = scratch(4, (out) => {
+        code = c.callAsync(ctx, handle, method, argsJson2, event, out);
+        return unsigned(out);
+      });
+      return code === OK ? call : fail(`callAsync ${method}`, code);
+    },
+    cancelCall: (call) => c.cancelCall(ctx, call) === OK,
+    cancelCalls: (handle) => outInt((out) => c.cancelCalls(ctx, handle, out)),
+    getDoubles(handle) {
+      const count = outInt((out) => c.doublesCount(ctx, handle, out));
+      if (!count) {
+        return [];
+      }
+      return scratch(count * 8, (buffer) => scratch(4, (copied) => {
+        c.doublesCopy(ctx, handle, buffer, count, copied);
+        return Array.from(new Float64Array(module.HEAPF64.buffer, buffer, count));
+      }));
+    },
+    getData(handle, path) {
+      const size = outInt((out) => c.dataSize(ctx, handle, path, out));
+      if (!size) {
+        return null;
+      }
+      return scratch(size, (buffer) => scratch(4, (copied) => c.dataCopy(ctx, handle, path, buffer, size, copied) === OK ? module.HEAPU8.slice(buffer, buffer + size).buffer : null));
+    },
+    on(handle, event, handler, delivery, coalesce, projection) {
+      const pointer = module.addFunction((userData, target, eventName, payload) => handler(target >>> 0, module.UTF8ToString(eventName), payload >>> 0) ? 1 : 0, "iiiii");
+      const options = JSON.stringify({ delivery: DELIVERY_UI, coalesce: !!coalesce, ...projection ? { projection } : {} });
+      const subscription = outInt((out) => c.on(ctx, handle, event, pointer, 0, options, out));
+      if (subscription) {
+        handlers.set(subscription, pointer);
+      } else {
+        module.removeFunction(pointer);
+      }
+      return subscription;
+    },
+    off(subscription) {
+      const removed = c.off(ctx, subscription) === OK;
+      const pointer = handlers.get(subscription);
+      if (pointer !== void 0) {
+        module.removeFunction(pointer);
+        handlers.delete(subscription);
+      }
+      return removed;
+    },
+    // Table slots of these subscriptions stay until the page goes: the ABI does not say which they were.
+    offAll: (handle) => outInt((out) => c.offAll(ctx, handle, out)),
+    adoptOptions: (kind, id, native) => native?.webPart === "options" ? c.adopt(kind, "options", id) : 0,
+    adoptLayers: (kind, id, native) => native?.webPart === "layers" ? c.adopt(kind, "layers", id) : 0,
+    adoptView: (kind, id, native) => native?.webPart === "view" ? c.adopt(kind, "view", id) : 0,
+    // Layers, sources and assets are only ever built from specs on the web: there is no object API.
+    adoptLayer: () => 0,
+    adoptSource: () => 0,
+    adoptAssets: () => 0,
+    getNativeLayer(id) {
+      const handle = outInt((out) => c.find(ctx, "layer", id, out));
+      return handle ? { webLayer: handle } : null;
+    },
+    getNativeSource: () => null,
+    getNativeLayerByHandle: (handle) => ({ webLayer: handle }),
+    getNativeSourceByHandle: () => null,
+    attachMapEvents: (mapView, handle) => c.attachMapEvents(handle),
+    attachVectorTileEvents: (layer, handle) => void c.bridgeLayerClicks(handle),
+    attachVectorElementEvents: (layer, handle) => void c.bridgeLayerClicks(handle),
+    attachCelestialEvents: (layer, handle) => void c.bridgeLayerClicks(handle),
+    nativeShortClassName: () => null,
+    /** The tokens a MapViewLike hands to the adopt calls above. */
+    parts: { view: part("view"), options: part("options"), layers: part("layers") }
+  };
+}
+
+// ../../dist/web/massif.mjs
+function canvasSelector(canvas, id = "map") {
+  if (!canvas.id) {
+    canvas.id = `massif-${id}`;
+  }
+  return `#${canvas.id}`;
+}
+var MODULE_FILE = "massif-web.mjs";
+async function loadModule({ moduleUrl = new URL(MODULE_FILE, import.meta.url).href, ...options } = {}) {
+  const { default: factory } = await import(
+    /* webpackIgnore: true */
+    moduleUrl
+  );
+  const base = new URL(".", new URL(moduleUrl, location.href)).href;
+  return factory({ locateFile: (path) => base + path, ...options });
+}
+
+// ../../dist/web/index.mjs
+var created = false;
+async function createMap(canvas, { id = "map", projection = "EPSG:4326", ...moduleOptions } = {}) {
+  if (created) {
+    throw new Error("createMap: this page already has a map");
+  }
+  created = true;
+  const module = await loadModule(moduleOptions);
+  const bridge2 = createBridge(module);
+  setBridge(bridge2);
+  if (!module.ccall("massifCreateMap", "number", ["string"], [canvasSelector(canvas, id)])) {
+    throw new Error("createMap: this browser has no WebGL 2");
+  }
+  const view = {
+    mapView: { getLayers: () => bridge2.parts.layers, getBaseMapView: () => bridge2.parts.view },
+    getOptions: () => ({ getNative: () => bridge2.parts.options }),
+    getMeasuredWidth: () => canvas.width,
+    getMeasuredHeight: () => canvas.height
+  };
+  const map = attach(view, { id, projection });
+  map.module = module;
+  return map;
+}
+export {
+  MapCamera,
+  MapLayers,
+  MassifApiError,
+  MassifElements,
+  MassifLayer,
+  MassifMap,
+  MassifObject,
+  MassifSource,
+  PropertyGroup,
+  Result,
+  Subscription,
+  adoptAssets,
+  adoptLayer,
+  adoptSource,
+  attach,
+  canConsume,
+  create,
+  createLayer,
+  createMap,
+  createSource,
+  destroy,
+  find,
+  isAvailable,
+  log,
+  setBridge,
+  wrap,
+  wrapLayer
+};