@performant-software/geospatial 3.1.25-beta.0 → 3.1.25-beta.2

package/dist/index.es233.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es233.js","sources":["../../../node_modules/d3-geo/src/area.js"],"sourcesContent":["import adder from \"./adder\";\nimport {atan2, cos, quarterPi, radians, sin, tau} from \"./math\";\nimport noop from \"./noop\";\nimport stream from \"./stream\";\n\nexport var areaRingSum = adder();\n\nvar areaSum = adder(),\n    lambda00,\n    phi00,\n    lambda0,\n    cosPhi0,\n    sinPhi0;\n\nexport var areaStream = {\n  point: noop,\n  lineStart: noop,\n  lineEnd: noop,\n  polygonStart: function() {\n    areaRingSum.reset();\n    areaStream.lineStart = areaRingStart;\n    areaStream.lineEnd = areaRingEnd;\n  },\n  polygonEnd: function() {\n    var areaRing = +areaRingSum;\n    areaSum.add(areaRing < 0 ? tau + areaRing : areaRing);\n    this.lineStart = this.lineEnd = this.point = noop;\n  },\n  sphere: function() {\n    areaSum.add(tau);\n  }\n};\n\nfunction areaRingStart() {\n  areaStream.point = areaPointFirst;\n}\n\nfunction areaRingEnd() {\n  areaPoint(lambda00, phi00);\n}\n\nfunction areaPointFirst(lambda, phi) {\n  areaStream.point = areaPoint;\n  lambda00 = lambda, phi00 = phi;\n  lambda *= radians, phi *= radians;\n  lambda0 = lambda, cosPhi0 = cos(phi = phi / 2 + quarterPi), sinPhi0 = sin(phi);\n}\n\nfunction areaPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  phi = phi / 2 + quarterPi; // half the angular distance from south pole\n\n  // Spherical excess E for a spherical triangle with vertices: south pole,\n  // previous point, current point.  Uses a formula derived from Cagnoli’s\n  // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).\n  var dLambda = lambda - lambda0,\n      sdLambda = dLambda >= 0 ? 1 : -1,\n      adLambda = sdLambda * dLambda,\n      cosPhi = cos(phi),\n      sinPhi = sin(phi),\n      k = sinPhi0 * sinPhi,\n      u = cosPhi0 * cosPhi + k * cos(adLambda),\n      v = k * sdLambda * sin(adLambda);\n  areaRingSum.add(atan2(v, u));\n\n  // Advance the previous points.\n  lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;\n}\n\nexport default function(object) {\n  areaSum.reset();\n  stream(object, areaStream);\n  return areaSum * 2;\n}\n"],"names":["adder"],"mappings":";AAKyBA,EAAA;AAEXA,EAAA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es233.js","sources":["../../../node_modules/@allmaps/warpedmaplayer/dist/WarpedMapLayer.js"],"sourcesContent":["import { WarpedMapEventType } from '@allmaps/render';\nimport { mergeOptions, mergePartialOptions } from '@allmaps/stdlib';\nconst NO_RENDERER_ERROR_MESSAGE = 'Renderer not defined. Add the layer to a map before calling this function.';\nconst NO_CANVAS_ERROR_MESSAGE = 'Canvas not defined. Add the layer to a map before calling this function.';\n/**\n * Base WarpedMapLayer class.\n */\nexport class BaseWarpedMapLayer {\n    defaultSpecificWarpedMapLayerOptions;\n    options;\n    container;\n    canvas;\n    gl;\n    renderer;\n    /**\n     * Creates a WarpedMapLayer instance\n     *\n     * @param options - options\n     */\n    constructor(defaultSpecificWarpedMapLayerOptions, options) {\n        this.defaultSpecificWarpedMapLayerOptions =\n            defaultSpecificWarpedMapLayerOptions;\n        this.options = mergeOptions(this.defaultSpecificWarpedMapLayerOptions, options);\n    }\n    // Normal functions\n    // These function are copied automatically to @allmaps/openlayers and @allmaps/leaflet's WarpedMapLayer.ts\n    // START_AUTOMATED_COPY\n    /**\n     * Adds a Georeference Annotation\n     *\n     * @param annotation - Georeference Annotation\n     * @param mapOptions - Map options\n     * @returns Map IDs of the maps that were added, or an error per map\n     */\n    addGeoreferenceAnnotation(annotation, mapOptions) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        const results = this.renderer.addGeoreferenceAnnotation(annotation, mapOptions);\n        this.nativeUpdate();\n        return results;\n    }\n    /**\n     * Removes a Georeference Annotation\n     *\n     * @param annotation - Georeference Annotation\n     * @returns Map IDs of the maps that were removed, or an error per map\n     */\n    removeGeoreferenceAnnotation(annotation) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        const results = this.renderer.warpedMapList.removeGeoreferenceAnnotation(annotation);\n        this.nativeUpdate();\n        return results;\n    }\n    /**\n     * Adds a Georeference Annotation by URL\n     *\n     * @param annotationUrl - URL of a Georeference Annotation\n     * @param mapOptions - Map options\n     * @returns Map IDs of the maps that were added, or an error per map\n     */\n    async addGeoreferenceAnnotationByUrl(annotationUrl, mapOptions) {\n        const annotation = await fetch(annotationUrl).then((response) => response.json());\n        return this.addGeoreferenceAnnotation(annotation, mapOptions);\n    }\n    /**\n     * Removes a Georeference Annotation by URL\n     *\n     * @param annotationUrl - URL of a Georeference Annotation\n     * @returns Map IDs of the maps that were removed, or an error per map\n     */\n    async removeGeoreferenceAnnotationByUrl(annotationUrl) {\n        const annotation = await fetch(annotationUrl).then((response) => response.json());\n        return this.removeGeoreferenceAnnotation(annotation);\n    }\n    /**\n     * Adds a Georeferenced Map\n     *\n     * @param georeferencedMap - Georeferenced Map\n     * @param mapOptions - Map options\n     * @returns Map ID of the map that was added\n     */\n    addGeoreferencedMap(georeferencedMap, mapOptions) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        const result = this.renderer.addGeoreferencedMap(georeferencedMap, mapOptions);\n        this.nativeUpdate();\n        return result;\n    }\n    /**\n     * Removes a Georeferenced Map\n     *\n     * @param georeferencedMap - Georeferenced Map\n     * @returns Map ID of the map that was removed\n     */\n    removeGeoreferencedMap(georeferencedMap) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        const result = this.renderer.warpedMapList.removeGeoreferencedMap(georeferencedMap);\n        this.nativeUpdate();\n        return result;\n    }\n    /**\n     * Removes a Georeferenced Map by its ID\n     *\n     * @param mapId - Map ID of the georeferenced map to remove\n     * @returns Map ID of the map that was removed\n     */\n    removeGeoreferencedMapById(mapId) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        const result = this.renderer.warpedMapList.removeGeoreferencedMapById(mapId);\n        this.nativeUpdate();\n        return result;\n    }\n    /**\n     * Adds image information to the WarpedMapList's image information cache\n     *\n     * @param imageInfos - Image informations\n     * @returns Image IDs of the image informations that were added\n     */\n    addImageInfos(imageInfos) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        const result = this.renderer.warpedMapList.addImageInfos(imageInfos);\n        this.nativeUpdate();\n        return result;\n    }\n    /**\n     * Adds sprites to the Renderer's sprite tile cache\n     *\n     * This adds tiles from sprites to warped maps in WarpedMapList. Load maps before running this function.\n     * This uses the image info of related maps. When using addImageInfos(), call it before calling this function.\n     *\n     * @param sprites - Sprites\n     * @param imageUrl - Image url\n     * @param imageSize - Image size\n     */\n    async addSprites(sprites, imageUrl, imageSize) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        await this.renderer.addSprites(sprites, imageUrl, imageSize);\n        this.nativeUpdate();\n        return;\n    }\n    /**\n     * Get the WarpedMapList object that contains a list of the warped maps of all loaded maps\n     */\n    getWarpedMapList() {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList;\n    }\n    /**\n     * Get mapIds for all maps in the layer\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @returns The mapIds of all maps\n     */\n    getMapIds() {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapIds();\n    }\n    /**\n     * Get the WarpedMap instances for all maps, or all selected maps\n     *\n     * If no argument is passed, the WarpedMap instance of all maps in the layer is passed\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @param mapIds - Map IDs\n     * @returns The WarpedMap instance of all (selected) map\n     */\n    getWarpedMaps(mapIds) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getWarpedMaps({ mapIds });\n    }\n    /**\n     * Get the WarpedMap instance for a map\n     *\n     * @param mapId - Map ID of the requested WarpedMap instance\n     */\n    getWarpedMap(mapId) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getWarpedMap(mapId);\n    }\n    /**\n     * Get the center of the bounding box of all maps in the layer\n     *\n     * The result is returned in lon-lat `EPSG:4326` by default.\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @param options - Mask and projection options, defaults to applied mask and current projection\n     * @returns The center of the bbox of all maps, in the chosen projection, or undefined if there were no maps.\n     */\n    getCenter(options) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapsCenter(options);\n    }\n    /**\n     * Get the center of the bounding box of all selected maps\n     *\n     * The result is returned in lon-lat `EPSG:4326` by default.\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @param mapIds - Map IDs\n     * @param options - Mask and projection options, defaults to applied mask and current projection\n     * @returns The center of the bbox of all selected maps, in the chosen projection, or undefined if there were no maps matching the selection.\n     */\n    getMapsCenter(mapIds, options) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapsCenter(mergePartialOptions({ mapIds }, options));\n    }\n    /**\n     * Get the bounding box of all maps in the layer\n     *\n     * The result is returned in lon-lat `EPSG:4326` by default.\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @param options - Mask and projection options, defaults to applied mask and current projection\n     * @returns The bbox of all maps, in the chosen projection, or undefined if there were no maps.\n     */\n    getBbox(options) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapsBbox(options);\n    }\n    /**\n     * Get the bounding box of all selected maps\n     *\n     * The result is returned in lon-lat `EPSG:4326` by default.\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @param mapIds - Map IDs\n     * @param options - Mask and projection options, defaults to applied mask and current projection\n     * @returns The bbox of all selected maps, in the chosen projection, or undefined if there were no maps matching the selection.\n     */\n    getMapsBbox(mapIds, options) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapsBbox(mergePartialOptions({ mapIds }, options));\n    }\n    /**\n     * Get the convex hull of all maps in the layer\n     *\n     * The result is returned in lon-lat `EPSG:4326` by default.\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @param mapIds - Map IDs\n     * @param options - Mask and projection options, defaults to applied mask and current projection\n     * @returns The convex hull of all maps, in the chosen projection, or undefined if there were no maps.\n     */\n    getConvexHull(options) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapsConvexHull(options);\n    }\n    /**\n     * Get the convex hull of all selected maps maps\n     *\n     * The result is returned in lon-lat `EPSG:4326` by default.\n     *\n     * Note: more selection options are available on this function of WarpedMapList\n     *\n     * @param mapIds - Map IDs\n     * @param options - Mask and projection options, defaults to applied mask and current projection\n     * @returns The convex hull of all selected maps, in the chosen projection, or undefined if there were no maps matching the selection.\n     */\n    getMapsConvexHull(mapIds, options) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapsConvexHull(mergePartialOptions({ mapIds }, options));\n    }\n    /**\n     * Get the z-index of a map\n     *\n     * @param mapId - Map ID for which to get the z-index\n     * @returns The z-index of a map\n     */\n    getMapZIndex(mapId) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.warpedMapList.getMapZIndex(mapId);\n    }\n    /**\n     * Get the layer opacity\n     *\n     * Returns a number between 0 and 1 (the default)\n     */\n    getOpacity() {\n        return this.getLayerOptions().opacity ?? this.getDefaultOptions().opacity;\n    }\n    /**\n     * Get the default options the layer\n     */\n    getDefaultOptions() {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return mergeOptions(this.defaultSpecificWarpedMapLayerOptions, this.renderer.getDefaultOptions());\n    }\n    /**\n     * Get the default options of a map\n     *\n     * These come from the default option settings for WebGL2WarpedMaps and the map's georeferenced map proporties\n     *\n     * @param mapId - Map ID for which the options apply\n     */\n    getMapDefaultOptions(mapId) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.getMapDefaultOptions(mapId);\n    }\n    /**\n     * Get the layer options\n     */\n    getLayerOptions() {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return mergePartialOptions(this.options, this.renderer.getOptions());\n    }\n    /**\n     * Get the map-specific options of a map\n     *\n     * @param mapId - Map ID for which the options apply\n     */\n    getMapMapOptions(mapId) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.getMapMapOptions(mapId);\n    }\n    /**\n     * Get the options of a map\n     *\n     * These options are the result of merging the default, georeferenced map,\n     * layer and map-specific options of that map.\n     *\n     * @param mapId - Map ID for which the options apply\n     */\n    getMapOptions(mapId) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        return this.renderer.getMapOptions(mapId);\n    }\n    /**\n     * Set the layer opacity\n     *\n     * @param opacity - Layer opacity to set\n     */\n    setOpacity(opacity) {\n        this.setLayerOptions({ opacity });\n    }\n    /**\n     * Set the options\n     *\n     * @param options - Options to set\n     */\n    setOptions(options) {\n        this.options = mergeOptions(this.options, options);\n    }\n    /**\n     * Set the layer options\n     *\n     * Doesn't set render options or specific warped map layer options. Use setOptions() instead.\n     *\n     * @param layerOptions - Layer options to set\n     * @param animationOptions - Animation options\n     * ```js\n     * warpedMapLayer.setLayerOptions({ transformationType: 'thinPlateSpline' })\n     * ```\n     */\n    setLayerOptions(layerOptions, animationOptions) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.setListOptions(layerOptions, animationOptions);\n    }\n    /**\n     * Set the transformation type of the layer\n     *\n     * @param transformationType - Transformation type to set\n     * @param animationOptions - Animation options\n     */\n    setLayerTransformationType(transformationType, animationOptions) {\n        return this.setLayerOptions({ transformationType: transformationType }, animationOptions);\n    }\n    /**\n     * Set the GCPs of a map\n     *\n     * This only sets the map-specific `gcps` option of the map\n     * (or more specifically of the warped map used for rendering),\n     * overwriting the original GCPs inferred from the Georeference Annotation.\n     *\n     * The original GCPs can be reset by resetting the map-specific GCPs option,\n     * and stay accessible in the warped map's `map` property.\n     *\n     * @param mapId - Map ID for which to set the options\n     * @param gcps - GCPs to set\n     * @param animationOptions - Animation options\n     */\n    setMapGcps(mapId, gcps, animationOptions) {\n        return this.setMapOptions(mapId, { gcps }, animationOptions);\n    }\n    /**\n     * Set the resource mask of a map\n     *\n     * This only sets the map-specific `resourceMask` option of the map\n     * (or more specifically of the warped map used for rendering),\n     * overwriting the original resource mask inferred from the Georeference Annotation.\n     *\n     * The original resource mask can be reset by resetting the map-specific resource mask option,\n     * and stays accessible in the warped map's `map` property.\n     *\n     * @param mapId - Map ID for which to set the options\n     * @param resourceMask - Resource mask to set\n     * @param animationOptions - Animation options\n     */\n    setMapResourceMask(mapId, resourceMask, animationOptions) {\n        return this.setMapOptions(mapId, { resourceMask }, animationOptions);\n    }\n    /**\n     * Set the transformation type of a map\n     *\n     * This only sets the map-specific `transformationType` option of the map\n     * (or more specifically of the warped map used for rendering),\n     * overwriting the original transformation type inferred from the Georeference Annotation.\n     *\n     * The original transformation type can be reset by resetting the map-specific transformation type option,\n     * and stays accessible in the warped map's `map` property.\n     *\n     * @param mapId - Map ID for which to set the options\n     * @param transformationType - Transformation type to set\n     * @param animationOptions - Animation options\n     */\n    setMapTransformationType(mapId, transformationType, animationOptions) {\n        return this.setMapOptions(mapId, { transformationType: transformationType }, animationOptions);\n    }\n    /**\n     * Set the transformation type of maps\n     *\n     * This only sets the map-specific `transformationType` option of the map\n     * (or more specifically of the warped map used for rendering),\n     * overwriting the original transformation type inferred from the Georeference Annotation.\n     *\n     * The original transformation type can be reset by resetting the map-specific transformation type option,\n     * and stays accessible in the warped map's `map` property.\n     *\n     * @param mapIds - Map IDs for which to set the options\n     * @param transformationType - Transformation type to set\n     * @param animationOptions - Animation options\n     */\n    setMapsTransformationType(mapIds, transformationType, animationOptions) {\n        return this.setMapsOptions(mapIds, { transformationType: transformationType }, animationOptions);\n    }\n    /**\n     * Set the map-specific options of a map\n     *\n     * In general setting a map-specific option\n     * also sets the corresponding option of the map,\n     * since these are the result of merging the default, georeferenced map,\n     * layer and map-specific options of that map.\n     *\n     * A special case is setting a map-specific option to `undefined`:\n     * then the corresponding option is derived from the default, georeferenced map or layer option.\n     * This is equivalent to using the reset function for map-specific option.\n     *\n     * @param mapId - Map ID for which to set the options\n     * @param mapOptions - Map-specific options to set\n     * @param animationOptions - Animation options\n     * @example\n     * ```js\n     * warpedMapLayer.setMapOptions(myMapId, { transformationType: 'thinPlateSpline' })\n     * ```\n     */\n    setMapOptions(mapId, mapOptions, animationOptions) {\n        return this.setMapsOptions([mapId], mapOptions, animationOptions);\n    }\n    setMapsOptions(firstArgument, secondArgument, thirdArgument) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.setMapsOptions(firstArgument, secondArgument, thirdArgument);\n    }\n    setMapsAndLayerOptions(firstArgument, secondArgument, thirdArgument, fourthArgument) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.setMapsAndListOptions(firstArgument, secondArgument, thirdArgument, fourthArgument);\n    }\n    /**\n     * Reset the layer options\n     *\n     * Undefined option keys reset all options\n     *\n     * Doesn't reset render options or specific warped map layer options. Use setOptions() instead.\n     *\n     * @param layerOptionKeys - Keys of the layer options to reset\n     * @param animationOptions - Animation options\n     */\n    resetLayerOptions(layerOptionKeys, animationOptions) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.resetListOptions(layerOptionKeys, animationOptions);\n    }\n    resetMapsOptions(firstArgument, secondArgument, thirdArgument) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.resetMapsOptions(firstArgument, secondArgument, thirdArgument);\n    }\n    resetMapsAndListOptions(firstArgument, secondArgument, thirdArgument, fourthArgument) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.resetMapsAndListOptions(firstArgument, secondArgument, thirdArgument, fourthArgument);\n    }\n    /**\n     * Bring maps to front\n     * @param mapIds - IDs of the maps\n     */\n    bringMapsToFront(mapIds) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.warpedMapList.bringMapsToFront(mapIds);\n        this.nativeUpdate();\n    }\n    /**\n     * Send maps to back\n     * @param mapIds - IDs of the maps\n     */\n    sendMapsToBack(mapIds) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.warpedMapList.sendMapsToBack(mapIds);\n        this.nativeUpdate();\n    }\n    /**\n     * Bring maps forward\n     * @param mapIds - IDs of the maps\n     */\n    bringMapsForward(mapIds) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.warpedMapList.bringMapsForward(mapIds);\n        this.nativeUpdate();\n    }\n    /**\n     * Send maps backward\n     * @param mapIds - IDs of the maps\n     */\n    sendMapsBackward(mapIds) {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.warpedMapList.sendMapsBackward(mapIds);\n        this.nativeUpdate();\n    }\n    /**\n     * Removes all warped maps from the layer\n     */\n    clear() {\n        BaseWarpedMapLayer.assertRenderer(this.renderer);\n        this.renderer.clear();\n        this.nativeUpdate();\n    }\n    contextLost(event) {\n        event.preventDefault();\n        this.renderer?.contextLost();\n    }\n    contextRestored(event) {\n        event.preventDefault();\n        this.renderer?.contextRestored();\n    }\n    addEventListeners() {\n        if (!this.renderer) {\n            return;\n        }\n        this.renderer.warpedMapList.addEventListener(WarpedMapEventType.IMAGEINFOSADDED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.addEventListener(WarpedMapEventType.WARPEDMAPADDED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.addEventListener(WarpedMapEventType.WARPEDMAPREMOVED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.addEventListener(WarpedMapEventType.WARPEDMAPENTERED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.addEventListener(WarpedMapEventType.WARPEDMAPLEFT, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.addEventListener(WarpedMapEventType.IMAGELOADED, this.nativeUpdate.bind(this));\n        this.renderer.addEventListener(WarpedMapEventType.ERROR, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.addEventListener(WarpedMapEventType.MAPTILELOADED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.spritesTileCache.addEventListener(WarpedMapEventType.MAPTILESLOADEDFROMSPRITES, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.addEventListener(WarpedMapEventType.MAPTILEDELETED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.addEventListener(WarpedMapEventType.FIRSTMAPTILELOADED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.addEventListener(WarpedMapEventType.ALLREQUESTEDTILESLOADED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.addEventListener(WarpedMapEventType.CLEARED, this.nativeUpdate.bind(this));\n        this.renderer.warpedMapList.addEventListener(WarpedMapEventType.PREPARECHANGE, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.addEventListener(WarpedMapEventType.IMMEDIATECHANGE, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.addEventListener(WarpedMapEventType.ANIMATEDCHANGE, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.addEventListener(WarpedMapEventType.CHANGED, this.nativeUpdate.bind(this));\n    }\n    removeEventListeners() {\n        if (!this.renderer) {\n            return;\n        }\n        this.renderer.warpedMapList.removeEventListener(WarpedMapEventType.IMAGEINFOSADDED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.removeEventListener(WarpedMapEventType.WARPEDMAPADDED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.removeEventListener(WarpedMapEventType.WARPEDMAPREMOVED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.removeEventListener(WarpedMapEventType.WARPEDMAPENTERED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.removeEventListener(WarpedMapEventType.WARPEDMAPLEFT, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.removeEventListener(WarpedMapEventType.IMAGELOADED, this.nativeUpdate.bind(this));\n        this.renderer.removeEventListener(WarpedMapEventType.ERROR, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.removeEventListener(WarpedMapEventType.MAPTILELOADED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.spritesTileCache.removeEventListener(WarpedMapEventType.MAPTILESLOADEDFROMSPRITES, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.removeEventListener(WarpedMapEventType.MAPTILEDELETED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.removeEventListener(WarpedMapEventType.FIRSTMAPTILELOADED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.tileCache.removeEventListener(WarpedMapEventType.ALLREQUESTEDTILESLOADED, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.removeEventListener(WarpedMapEventType.CLEARED, this.nativeUpdate.bind(this));\n        this.renderer.warpedMapList.removeEventListener(WarpedMapEventType.PREPARECHANGE, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.removeEventListener(WarpedMapEventType.IMMEDIATECHANGE, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.warpedMapList.removeEventListener(WarpedMapEventType.ANIMATEDCHANGE, this.nativePassWarpedMapEvent.bind(this));\n        this.renderer.removeEventListener(WarpedMapEventType.CHANGED, this.nativeUpdate.bind(this));\n    }\n    // END_AUTOMATED_COPY\n    // Static functions\n    static assertRenderer(renderer) {\n        if (!renderer) {\n            throw new Error(NO_RENDERER_ERROR_MESSAGE);\n        }\n    }\n    static assertCanvas(canvas) {\n        if (!canvas) {\n            throw new Error(NO_CANVAS_ERROR_MESSAGE);\n        }\n    }\n}\n"],"names":["NO_RENDERER_ERROR_MESSAGE","NO_CANVAS_ERROR_MESSAGE","BaseWarpedMapLayer","defaultSpecificWarpedMapLayerOptions","options","mergeOptions","annotation","mapOptions","results","annotationUrl","response","georeferencedMap","result","mapId","imageInfos","sprites","imageUrl","imageSize","mapIds","mergePartialOptions","opacity","layerOptions","animationOptions","transformationType","gcps","resourceMask","firstArgument","secondArgument","thirdArgument","fourthArgument","layerOptionKeys","event","WarpedMapEventType","renderer","canvas"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es234.js

@@ -1,4 +1,29 @@
-import r from "./index.es252.js";
-import "./index.es233.js";
-r();
+import "./index.es223.js";
+import { computeBbox as j } from "./index.es215.js";
+import { midPoint as r } from "./index.es275.js";
+import { angle as f, radiansToDegrees as c, angularMean as R } from "./index.es216.js";
+import { mergeOptions as A } from "./index.es217.js";
+import "./index.es224.js";
+import "./index.es225.js";
+const I = {};
+function v(t, e) {
+  if (t.gcps.length < 2)
+    throw new Error("Not enough GCPs to compute bearing");
+  const n = t.getProjectedTransformer(e?.transformationType, e);
+  return L(t.getResourceAppliedMask(e?.applyMask), n, e);
+}
+function L(t, e, n) {
+  const s = A(I, n), o = j(t), i = [o[0], o[1]], a = [o[0], o[3]], m = [o[2], o[1]], u = [
+    o[2],
+    o[3]
+  ], l = r(i, m), h = r(a, u), T = e.transformToProjectedGeo(l), G = e.transformToProjectedGeo(h), P = r(m, u), d = r(i, a), B = e.transformToProjectedGeo(d), C = e.transformToProjectedGeo(P), p = f([G, T]), g = f([
+    B,
+    C
+  ]);
+  return s.orientation == "horizontal" ? -c(g) : s.orientation == "vertical" ? -c(p - Math.PI / 2) : -c(R(p - Math.PI / 2, g));
+}
+export {
+  I as DEFAULT_BEARING_OPTIONS,
+  v as computeWarpedMapBearing
+};
 //# sourceMappingURL=index.es234.js.map

package/dist/index.es234.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es234.js","sources":["../../../node_modules/d3-geo/src/bounds.js"],"sourcesContent":["import adder from \"./adder\";\nimport {areaStream, areaRingSum} from \"./area\";\nimport {cartesian, cartesianCross, cartesianNormalizeInPlace, spherical} from \"./cartesian\";\nimport {abs, degrees, epsilon, radians} from \"./math\";\nimport stream from \"./stream\";\n\nvar lambda0, phi0, lambda1, phi1, // bounds\n    lambda2, // previous lambda-coordinate\n    lambda00, phi00, // first point\n    p0, // previous 3D point\n    deltaSum = adder(),\n    ranges,\n    range;\n\nvar boundsStream = {\n  point: boundsPoint,\n  lineStart: boundsLineStart,\n  lineEnd: boundsLineEnd,\n  polygonStart: function() {\n    boundsStream.point = boundsRingPoint;\n    boundsStream.lineStart = boundsRingStart;\n    boundsStream.lineEnd = boundsRingEnd;\n    deltaSum.reset();\n    areaStream.polygonStart();\n  },\n  polygonEnd: function() {\n    areaStream.polygonEnd();\n    boundsStream.point = boundsPoint;\n    boundsStream.lineStart = boundsLineStart;\n    boundsStream.lineEnd = boundsLineEnd;\n    if (areaRingSum < 0) lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);\n    else if (deltaSum > epsilon) phi1 = 90;\n    else if (deltaSum < -epsilon) phi0 = -90;\n    range[0] = lambda0, range[1] = lambda1;\n  }\n};\n\nfunction boundsPoint(lambda, phi) {\n  ranges.push(range = [lambda0 = lambda, lambda1 = lambda]);\n  if (phi < phi0) phi0 = phi;\n  if (phi > phi1) phi1 = phi;\n}\n\nfunction linePoint(lambda, phi) {\n  var p = cartesian([lambda * radians, phi * radians]);\n  if (p0) {\n    var normal = cartesianCross(p0, p),\n        equatorial = [normal[1], -normal[0], 0],\n        inflection = cartesianCross(equatorial, normal);\n    cartesianNormalizeInPlace(inflection);\n    inflection = spherical(inflection);\n    var delta = lambda - lambda2,\n        sign = delta > 0 ? 1 : -1,\n        lambdai = inflection[0] * degrees * sign,\n        phii,\n        antimeridian = abs(delta) > 180;\n    if (antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {\n      phii = inflection[1] * degrees;\n      if (phii > phi1) phi1 = phii;\n    } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {\n      phii = -inflection[1] * degrees;\n      if (phii < phi0) phi0 = phii;\n    } else {\n      if (phi < phi0) phi0 = phi;\n      if (phi > phi1) phi1 = phi;\n    }\n    if (antimeridian) {\n      if (lambda < lambda2) {\n        if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;\n      } else {\n        if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;\n      }\n    } else {\n      if (lambda1 >= lambda0) {\n        if (lambda < lambda0) lambda0 = lambda;\n        if (lambda > lambda1) lambda1 = lambda;\n      } else {\n        if (lambda > lambda2) {\n          if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;\n        } else {\n          if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;\n        }\n      }\n    }\n  } else {\n    ranges.push(range = [lambda0 = lambda, lambda1 = lambda]);\n  }\n  if (phi < phi0) phi0 = phi;\n  if (phi > phi1) phi1 = phi;\n  p0 = p, lambda2 = lambda;\n}\n\nfunction boundsLineStart() {\n  boundsStream.point = linePoint;\n}\n\nfunction boundsLineEnd() {\n  range[0] = lambda0, range[1] = lambda1;\n  boundsStream.point = boundsPoint;\n  p0 = null;\n}\n\nfunction boundsRingPoint(lambda, phi) {\n  if (p0) {\n    var delta = lambda - lambda2;\n    deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);\n  } else {\n    lambda00 = lambda, phi00 = phi;\n  }\n  areaStream.point(lambda, phi);\n  linePoint(lambda, phi);\n}\n\nfunction boundsRingStart() {\n  areaStream.lineStart();\n}\n\nfunction boundsRingEnd() {\n  boundsRingPoint(lambda00, phi00);\n  areaStream.lineEnd();\n  if (abs(deltaSum) > epsilon) lambda0 = -(lambda1 = 180);\n  range[0] = lambda0, range[1] = lambda1;\n  p0 = null;\n}\n\n// Finds the left-right distance between two longitudes.\n// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want\n// the distance between ±180° to be 360°.\nfunction angle(lambda0, lambda1) {\n  return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;\n}\n\nfunction rangeCompare(a, b) {\n  return a[0] - b[0];\n}\n\nfunction rangeContains(range, x) {\n  return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;\n}\n\nexport default function(feature) {\n  var i, n, a, b, merged, deltaMax, delta;\n\n  phi1 = lambda1 = -(lambda0 = phi0 = Infinity);\n  ranges = [];\n  stream(feature, boundsStream);\n\n  // First, sort ranges by their minimum longitudes.\n  if (n = ranges.length) {\n    ranges.sort(rangeCompare);\n\n    // Then, merge any ranges that overlap.\n    for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {\n      b = ranges[i];\n      if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {\n        if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];\n        if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];\n      } else {\n        merged.push(a = b);\n      }\n    }\n\n    // Finally, find the largest gap between the merged ranges.\n    // The final bounding box will be the inverse of this gap.\n    for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {\n      b = merged[i];\n      if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0 = b[0], lambda1 = a[1];\n    }\n  }\n\n  ranges = range = null;\n\n  return lambda0 === Infinity || phi0 === Infinity\n      ? [[NaN, NaN], [NaN, NaN]]\n      : [[lambda0, phi0], [lambda1, phi1]];\n}\n"],"names":["adder"],"mappings":";;AAUeA,EAAA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es234.js","sources":["../../../node_modules/@allmaps/bearing/dist/index.js"],"sourcesContent":["import { ProjectedGcpTransformer } from '@allmaps/project';\nimport { angle, angularMean, computeBbox, mergeOptions, midPoint, radiansToDegrees, sizeToRectangle } from '@allmaps/stdlib';\nexport const DEFAULT_BEARING_OPTIONS = {};\n/**\n * Compute the bearing of a Georeferenced Map.\n *\n * @param georeferencedMap - Georeferenced Map\n * @returns The bearing of the map in degrees, measured in degrees from the north line in the clockwise (negative) direction\n */\nexport function computeGeoreferencedMapBearing(georeferencedMap, options) {\n    if (georeferencedMap.gcps.length < 2) {\n        throw new Error('Not enough GCPs to compute bearing');\n    }\n    let resourceMask;\n    if (options?.applyMask === false) {\n        const width = georeferencedMap.resource.width;\n        const height = georeferencedMap.resource.height;\n        if (!width || !height) {\n            throw new Error('Width and height must be known to compute bearing without mask');\n        }\n        resourceMask = sizeToRectangle([width, height]);\n    }\n    else {\n        resourceMask = georeferencedMap.resourceMask;\n    }\n    const projectedTransformer = ProjectedGcpTransformer.fromGeoreferencedMap(georeferencedMap, options);\n    return computeBearingInternal(resourceMask, projectedTransformer, options);\n}\n/**\n * Compute the bearing of a Warped Map.\n *\n * @param warpedMap - Warped Map\n * @returns The bearing of the map in degrees, measured in degrees from the north line in the clockwise (negative) direction\n */\nexport function computeWarpedMapBearing(warpedMap, options) {\n    if (warpedMap.gcps.length < 2) {\n        throw new Error('Not enough GCPs to compute bearing');\n    }\n    const projectedTransformer = warpedMap.getProjectedTransformer(options?.transformationType, options);\n    return computeBearingInternal(warpedMap.getResourceAppliedMask(options?.applyMask), projectedTransformer, options);\n}\n// Compute the bearing by checking the orientation of\nfunction computeBearingInternal(resourceMask, projectedTransformer, partialOptions) {\n    const options = mergeOptions(DEFAULT_BEARING_OPTIONS, partialOptions);\n    const resourceMaskBbox = computeBbox(resourceMask);\n    const resourceTopLeft = [resourceMaskBbox[0], resourceMaskBbox[1]];\n    const resourceBottomLeft = [resourceMaskBbox[0], resourceMaskBbox[3]];\n    const resourceTopRight = [resourceMaskBbox[2], resourceMaskBbox[1]];\n    const resourceBottomRight = [\n        resourceMaskBbox[2],\n        resourceMaskBbox[3]\n    ];\n    const resourceTopCenter = midPoint(resourceTopLeft, resourceTopRight);\n    const resourceBottomCenter = midPoint(resourceBottomLeft, resourceBottomRight);\n    const projectedGeoTopCenter = projectedTransformer.transformToProjectedGeo(resourceTopCenter);\n    const projectedGeoBottomCenter = projectedTransformer.transformToProjectedGeo(resourceBottomCenter);\n    const resourceCenterRight = midPoint(resourceTopRight, resourceBottomRight);\n    const resourceCenterLeft = midPoint(resourceTopLeft, resourceBottomLeft);\n    const projectedGeoCenterLeft = projectedTransformer.transformToProjectedGeo(resourceCenterLeft);\n    const projectedGeoCenterRight = projectedTransformer.transformToProjectedGeo(resourceCenterRight);\n    const verticalAngle = angle([projectedGeoBottomCenter, projectedGeoTopCenter]);\n    const horizontalAngle = angle([\n        projectedGeoCenterLeft,\n        projectedGeoCenterRight\n    ]);\n    if (options.orientation == 'horizontal') {\n        return -radiansToDegrees(horizontalAngle);\n    }\n    else if (options.orientation == 'vertical') {\n        return -radiansToDegrees(verticalAngle - Math.PI / 2);\n    }\n    else {\n        return -radiansToDegrees(angularMean(verticalAngle - Math.PI / 2, horizontalAngle));\n    }\n}\n"],"names":["DEFAULT_BEARING_OPTIONS","computeWarpedMapBearing","warpedMap","options","projectedTransformer","computeBearingInternal","resourceMask","partialOptions","mergeOptions","resourceMaskBbox","computeBbox","resourceTopLeft","resourceBottomLeft","resourceTopRight","resourceBottomRight","resourceTopCenter","midPoint","resourceBottomCenter","projectedGeoTopCenter","projectedGeoBottomCenter","resourceCenterRight","resourceCenterLeft","projectedGeoCenterLeft","projectedGeoCenterRight","verticalAngle","angle","horizontalAngle","radiansToDegrees","angularMean"],"mappings":";;;;;;;AAEO,MAAMA,IAA0B,CAAA;AAgChC,SAASC,EAAwBC,GAAWC,GAAS;AACxD,MAAID,EAAU,KAAK,SAAS;AACxB,UAAM,IAAI,MAAM,oCAAoC;AAExD,QAAME,IAAuBF,EAAU,wBAAwBC,GAAS,oBAAoBA,CAAO;AACnG,SAAOE,EAAuBH,EAAU,uBAAuBC,GAAS,SAAS,GAAGC,GAAsBD,CAAO;AACrH;AAEA,SAASE,EAAuBC,GAAcF,GAAsBG,GAAgB;AAChF,QAAMJ,IAAUK,EAAaR,GAAyBO,CAAc,GAC9DE,IAAmBC,EAAYJ,CAAY,GAC3CK,IAAkB,CAACF,EAAiB,CAAC,GAAGA,EAAiB,CAAC,CAAC,GAC3DG,IAAqB,CAACH,EAAiB,CAAC,GAAGA,EAAiB,CAAC,CAAC,GAC9DI,IAAmB,CAACJ,EAAiB,CAAC,GAAGA,EAAiB,CAAC,CAAC,GAC5DK,IAAsB;AAAA,IACxBL,EAAiB,CAAC;AAAA,IAClBA,EAAiB,CAAC;AAAA,EAAA,GAEhBM,IAAoBC,EAASL,GAAiBE,CAAgB,GAC9DI,IAAuBD,EAASJ,GAAoBE,CAAmB,GACvEI,IAAwBd,EAAqB,wBAAwBW,CAAiB,GACtFI,IAA2Bf,EAAqB,wBAAwBa,CAAoB,GAC5FG,IAAsBJ,EAASH,GAAkBC,CAAmB,GACpEO,IAAqBL,EAASL,GAAiBC,CAAkB,GACjEU,IAAyBlB,EAAqB,wBAAwBiB,CAAkB,GACxFE,IAA0BnB,EAAqB,wBAAwBgB,CAAmB,GAC1FI,IAAgBC,EAAM,CAACN,GAA0BD,CAAqB,CAAC,GACvEQ,IAAkBD,EAAM;AAAA,IAC1BH;AAAA,IACAC;AAAA,EAAA,CACH;AACD,SAAIpB,EAAQ,eAAe,eAChB,CAACwB,EAAiBD,CAAe,IAEnCvB,EAAQ,eAAe,aACrB,CAACwB,EAAiBH,IAAgB,KAAK,KAAK,CAAC,IAG7C,CAACG,EAAiBC,EAAYJ,IAAgB,KAAK,KAAK,GAAGE,CAAe,CAAC;AAE1F;","x_google_ignoreList":[0]}

package/dist/index.es235.js

@@ -1,39 +1,11 @@
-import A from "./index.es265.js";
-import { tau as p, atan2 as I, asin as P, pi as z, sin as t, cos as i } from "./index.es255.js";
-function R(r, n) {
-  return [r > z ? r - p : r < -z ? r + p : r, n];
-}
-R.invert = R;
-function E(r, n, o) {
-  return (r %= p) ? n || o ? A(j(r), q(n, o)) : j(r) : n || o ? q(n, o) : R;
-}
-function g(r) {
-  return function(n, o) {
-    return n += r, [n > z ? n - p : n < -z ? n + p : n, o];
+import { toString as n } from "./index.es37.js";
+function a(t) {
+  var r = "[object " + t + "]";
+  return function(e) {
+    return n.call(e) === r;
   };
 }
-function j(r) {
-  var n = g(r);
-  return n.invert = g(-r), n;
-}
-function q(r, n) {
-  var o = i(r), x = t(r), y = i(n), k = t(n);
-  function w(u, c) {
-    var f = i(c), s = i(u) * f, e = t(u) * f, v = t(c), D = v * o + s * x;
-    return [
-      I(e * y - D * k, s * o - v * x),
-      P(D * y + e * k)
-    ];
-  }
-  return w.invert = function(u, c) {
-    var f = i(c), s = i(u) * f, e = t(u) * f, v = t(c), D = v * y - e * k;
-    return [
-      I(e * y + v * k, s * o + D * x),
-      P(D * o - s * x)
-    ];
-  }, w;
-}
 export {
-  E as rotateRadians
+  a as default
 };
 //# sourceMappingURL=index.es235.js.map

package/dist/index.es235.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es235.js","sources":["../../../node_modules/d3-geo/src/rotation.js"],"sourcesContent":["import compose from \"./compose\";\nimport {asin, atan2, cos, degrees, pi, radians, sin, tau} from \"./math\";\n\nfunction rotationIdentity(lambda, phi) {\n  return [lambda > pi ? lambda - tau : lambda < -pi ? lambda + tau : lambda, phi];\n}\n\nrotationIdentity.invert = rotationIdentity;\n\nexport function rotateRadians(deltaLambda, deltaPhi, deltaGamma) {\n  return (deltaLambda %= tau) ? (deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma))\n    : rotationLambda(deltaLambda))\n    : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma)\n    : rotationIdentity);\n}\n\nfunction forwardRotationLambda(deltaLambda) {\n  return function(lambda, phi) {\n    return lambda += deltaLambda, [lambda > pi ? lambda - tau : lambda < -pi ? lambda + tau : lambda, phi];\n  };\n}\n\nfunction rotationLambda(deltaLambda) {\n  var rotation = forwardRotationLambda(deltaLambda);\n  rotation.invert = forwardRotationLambda(-deltaLambda);\n  return rotation;\n}\n\nfunction rotationPhiGamma(deltaPhi, deltaGamma) {\n  var cosDeltaPhi = cos(deltaPhi),\n      sinDeltaPhi = sin(deltaPhi),\n      cosDeltaGamma = cos(deltaGamma),\n      sinDeltaGamma = sin(deltaGamma);\n\n  function rotation(lambda, phi) {\n    var cosPhi = cos(phi),\n        x = cos(lambda) * cosPhi,\n        y = sin(lambda) * cosPhi,\n        z = sin(phi),\n        k = z * cosDeltaPhi + x * sinDeltaPhi;\n    return [\n      atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),\n      asin(k * cosDeltaGamma + y * sinDeltaGamma)\n    ];\n  }\n\n  rotation.invert = function(lambda, phi) {\n    var cosPhi = cos(phi),\n        x = cos(lambda) * cosPhi,\n        y = sin(lambda) * cosPhi,\n        z = sin(phi),\n        k = z * cosDeltaGamma - y * sinDeltaGamma;\n    return [\n      atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),\n      asin(k * cosDeltaPhi - x * sinDeltaPhi)\n    ];\n  };\n\n  return rotation;\n}\n\nexport default function(rotate) {\n  rotate = rotateRadians(rotate[0] * radians, rotate[1] * radians, rotate.length > 2 ? rotate[2] * radians : 0);\n\n  function forward(coordinates) {\n    coordinates = rotate(coordinates[0] * radians, coordinates[1] * radians);\n    return coordinates[0] *= degrees, coordinates[1] *= degrees, coordinates;\n  }\n\n  forward.invert = function(coordinates) {\n    coordinates = rotate.invert(coordinates[0] * radians, coordinates[1] * radians);\n    return coordinates[0] *= degrees, coordinates[1] *= degrees, coordinates;\n  };\n\n  return forward;\n}\n"],"names":["rotationIdentity","lambda","phi","pi","tau","rotateRadians","deltaLambda","deltaPhi","deltaGamma","compose","rotationLambda","rotationPhiGamma","forwardRotationLambda","rotation","cosDeltaPhi","cos","sinDeltaPhi","sin","cosDeltaGamma","sinDeltaGamma","cosPhi","x","y","z","k","atan2","asin"],"mappings":";;AAGA,SAASA,EAAiBC,GAAQC,GAAK;AACrC,SAAO,CAACD,IAASE,IAAKF,IAASG,IAAMH,IAAS,CAACE,IAAKF,IAASG,IAAMH,GAAQC,CAAG;AAChF;AAEAF,EAAiB,SAASA;AAEnB,SAASK,EAAcC,GAAaC,GAAUC,GAAY;AAC/D,UAAQF,KAAeF,KAAQG,KAAYC,IAAaC,EAAQC,EAAeJ,CAAW,GAAGK,EAAiBJ,GAAUC,CAAU,CAAC,IAC/HE,EAAeJ,CAAW,IACzBC,KAAYC,IAAaG,EAAiBJ,GAAUC,CAAU,IAC/DR;AACN;AAEA,SAASY,EAAsBN,GAAa;AAC1C,SAAO,SAASL,GAAQC,GAAK;AAC3B,WAAOD,KAAUK,GAAa,CAACL,IAASE,IAAKF,IAASG,IAAMH,IAAS,CAACE,IAAKF,IAASG,IAAMH,GAAQC,CAAG;AAAA,EACvG;AACF;AAEA,SAASQ,EAAeJ,GAAa;AACnC,MAAIO,IAAWD,EAAsBN,CAAW;AAChD,SAAAO,EAAS,SAASD,EAAsB,CAACN,CAAW,GAC7CO;AACT;AAEA,SAASF,EAAiBJ,GAAUC,GAAY;AAC9C,MAAIM,IAAcC,EAAIR,CAAQ,GAC1BS,IAAcC,EAAIV,CAAQ,GAC1BW,IAAgBH,EAAIP,CAAU,GAC9BW,IAAgBF,EAAIT,CAAU;AAElC,WAASK,EAASZ,GAAQC,GAAK;AAC7B,QAAIkB,IAASL,EAAIb,CAAG,GAChBmB,IAAIN,EAAId,CAAM,IAAImB,GAClBE,IAAIL,EAAIhB,CAAM,IAAImB,GAClBG,IAAIN,EAAIf,CAAG,GACXsB,IAAID,IAAIT,IAAcO,IAAIL;AAC9B,WAAO;AAAA,MACLS,EAAMH,IAAIJ,IAAgBM,IAAIL,GAAeE,IAAIP,IAAcS,IAAIP,CAAW;AAAA,MAC9EU,EAAKF,IAAIN,IAAgBI,IAAIH,CAAa;AAAA,IAAA;AAAA,EAE9C;AAEA,SAAAN,EAAS,SAAS,SAASZ,GAAQC,GAAK;AACtC,QAAIkB,IAASL,EAAIb,CAAG,GAChBmB,IAAIN,EAAId,CAAM,IAAImB,GAClBE,IAAIL,EAAIhB,CAAM,IAAImB,GAClBG,IAAIN,EAAIf,CAAG,GACXsB,IAAID,IAAIL,IAAgBI,IAAIH;AAChC,WAAO;AAAA,MACLM,EAAMH,IAAIJ,IAAgBK,IAAIJ,GAAeE,IAAIP,IAAcU,IAAIR,CAAW;AAAA,MAC9EU,EAAKF,IAAIV,IAAcO,IAAIL,CAAW;AAAA,IAAA;AAAA,EAE1C,GAEOH;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es235.js","sources":["../node_modules/underscore/modules/_tagTester.js"],"sourcesContent":["import { toString } from './_setup.js';\n\n// Internal function for creating a `toString`-based type tester.\nexport default function tagTester(name) {\n  var tag = '[object ' + name + ']';\n  return function(obj) {\n    return toString.call(obj) === tag;\n  };\n}\n"],"names":["tagTester","name","tag","obj","toString"],"mappings":";AAGA,SAAwBA,EAAUC,GAAM;AACtC,MAAIC,IAAM,aAAaD,IAAO;AAC9B,SAAO,SAASE,GAAK;AACnB,WAAOC,EAAS,KAAKD,CAAG,MAAMD;AAAA,EAChC;AACF;","x_google_ignoreList":[0]}

package/dist/index.es236.js

@@ -1,4 +1,8 @@
-import o from "./index.es274.js";
-import r from "./index.es275.js";
-r(o);
+import { hasOwnProperty as a } from "./index.es37.js";
+function n(r, t) {
+  return r != null && a.call(r, t);
+}
+export {
+  n as default
+};
 //# sourceMappingURL=index.es236.js.map

package/dist/index.es236.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es236.js","sources":["../../../node_modules/d3-geo/node_modules/d3-array/src/bisect.js"],"sourcesContent":["import ascending from \"./ascending\";\nimport bisector from \"./bisector\";\n\nvar ascendingBisect = bisector(ascending);\nexport var bisectRight = ascendingBisect.right;\nexport var bisectLeft = ascendingBisect.left;\nexport default bisectRight;\n"],"names":["bisector","ascending"],"mappings":";;AAGsBA,EAASC,CAAS;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es236.js","sources":["../node_modules/underscore/modules/_has.js"],"sourcesContent":["import { hasOwnProperty } from './_setup.js';\n\n// Internal function to check whether `key` is an own property name of `obj`.\nexport default function has(obj, key) {\n  return obj != null && hasOwnProperty.call(obj, key);\n}\n"],"names":["has","obj","key","hasOwnProperty"],"mappings":";AAGA,SAAwBA,EAAIC,GAAKC,GAAK;AACpC,SAAOD,KAAO,QAAQE,EAAe,KAAKF,GAAKC,CAAG;AACpD;","x_google_ignoreList":[0]}

package/dist/index.es237.js

@@ -1,26 +1,7 @@
-import Y from "./index.es252.js";
-import { cartesianCross as S, cartesian as T, cartesianNormalizeInPlace as U } from "./index.es254.js";
-import { quarterPi as V, atan2 as Z, sin as e, cos as s, asin as _, epsilon as g, pi as $, tau as k } from "./index.es255.js";
-var n = Y();
-function l(y, B) {
-  var f = B[0], E = B[1], W = [e(f), -s(f), 0], C = 0, F = 0;
-  n.reset();
-  for (var m = 0, X = y.length; m < X; ++m)
-    if (w = (q = y[m]).length)
-      for (var q, w, v = q[w - 1], x = v[0], G = v[1] / 2 + V, H = e(G), J = s(G), z = 0; z < w; ++z, x = I, H = L, J = M, v = o) {
-        var o = q[z], I = o[0], K = o[1] / 2 + V, L = e(K), M = s(K), r = I - x, N = r >= 0 ? 1 : -1, c = N * r, u = c > $, O = H * L;
-        if (n.add(Z(O * N * e(c), J * M + O * s(c))), C += u ? r + N * k : r, u ^ x >= f ^ I >= f) {
-          var a = S(T(v), T(o));
-          U(a);
-          var Q = S(W, a);
-          U(Q);
-          var R = (u ^ r >= 0 ? -1 : 1) * _(Q[2]);
-          (E > R || E === R && (a[0] || a[1])) && (F += u ^ r >= 0 ? 1 : -1);
-        }
-      }
-  return (C < -g || C < g && n < -g) ^ F & 1;
-}
+import e from "./index.es276.js";
+import t from "./index.es239.js";
+const f = e(t);
 export {
-  l as default
+  f as default
 };
 //# sourceMappingURL=index.es237.js.map

package/dist/index.es237.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es237.js","sources":["../../../node_modules/d3-geo/src/polygonContains.js"],"sourcesContent":["import adder from \"./adder\";\nimport {cartesian, cartesianCross, cartesianNormalizeInPlace} from \"./cartesian\";\nimport {asin, atan2, cos, epsilon, pi, quarterPi, sin, tau} from \"./math\";\n\nvar sum = adder();\n\nexport default function(polygon, point) {\n  var lambda = point[0],\n      phi = point[1],\n      normal = [sin(lambda), -cos(lambda), 0],\n      angle = 0,\n      winding = 0;\n\n  sum.reset();\n\n  for (var i = 0, n = polygon.length; i < n; ++i) {\n    if (!(m = (ring = polygon[i]).length)) continue;\n    var ring,\n        m,\n        point0 = ring[m - 1],\n        lambda0 = point0[0],\n        phi0 = point0[1] / 2 + quarterPi,\n        sinPhi0 = sin(phi0),\n        cosPhi0 = cos(phi0);\n\n    for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {\n      var point1 = ring[j],\n          lambda1 = point1[0],\n          phi1 = point1[1] / 2 + quarterPi,\n          sinPhi1 = sin(phi1),\n          cosPhi1 = cos(phi1),\n          delta = lambda1 - lambda0,\n          sign = delta >= 0 ? 1 : -1,\n          absDelta = sign * delta,\n          antimeridian = absDelta > pi,\n          k = sinPhi0 * sinPhi1;\n\n      sum.add(atan2(k * sign * sin(absDelta), cosPhi0 * cosPhi1 + k * cos(absDelta)));\n      angle += antimeridian ? delta + sign * tau : delta;\n\n      // Are the longitudes either side of the point’s meridian (lambda),\n      // and are the latitudes smaller than the parallel (phi)?\n      if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {\n        var arc = cartesianCross(cartesian(point0), cartesian(point1));\n        cartesianNormalizeInPlace(arc);\n        var intersection = cartesianCross(normal, arc);\n        cartesianNormalizeInPlace(intersection);\n        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);\n        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {\n          winding += antimeridian ^ delta >= 0 ? 1 : -1;\n        }\n      }\n    }\n  }\n\n  // First, determine whether the South pole is inside or outside:\n  //\n  // It is inside if:\n  // * the polygon winds around it in a clockwise direction.\n  // * the polygon does not (cumulatively) wind around it, but has a negative\n  //   (counter-clockwise) area.\n  //\n  // Second, count the (signed) number of times a segment crosses a lambda\n  // from the point to the South pole.  If it is zero, then the point is the\n  // same side as the South pole.\n\n  return (angle < -epsilon || angle < epsilon && sum < -epsilon) ^ (winding & 1);\n}\n"],"names":["sum","adder","polygonContains","polygon","point","lambda","phi","normal","sin","cos","angle","winding","i","n","m","ring","point0","lambda0","phi0","quarterPi","sinPhi0","cosPhi0","j","lambda1","sinPhi1","cosPhi1","point1","phi1","delta","sign","absDelta","antimeridian","pi","k","atan2","tau","arc","cartesianCross","cartesian","cartesianNormalizeInPlace","intersection","phiArc","asin","epsilon"],"mappings":";;;AAIA,IAAIA,IAAMC,EAAA;AAEV,SAAAC,EAAwBC,GAASC,GAAO;AACtC,MAAIC,IAASD,EAAM,CAAC,GAChBE,IAAMF,EAAM,CAAC,GACbG,IAAS,CAACC,EAAIH,CAAM,GAAG,CAACI,EAAIJ,CAAM,GAAG,CAAC,GACtCK,IAAQ,GACRC,IAAU;AAEd,EAAAX,EAAI,MAAA;AAEJ,WAASY,IAAI,GAAGC,IAAIV,EAAQ,QAAQS,IAAIC,GAAG,EAAED;AAC3C,QAAME,KAAKC,IAAOZ,EAAQS,CAAC,GAAG;AAS9B,eARIG,GACAD,GACAE,IAASD,EAAKD,IAAI,CAAC,GACnBG,IAAUD,EAAO,CAAC,GAClBE,IAAOF,EAAO,CAAC,IAAI,IAAIG,GACvBC,IAAUZ,EAAIU,CAAI,GAClBG,IAAUZ,EAAIS,CAAI,GAEbI,IAAI,GAAGA,IAAIR,GAAG,EAAEQ,GAAGL,IAAUM,GAASH,IAAUI,GAASH,IAAUI,GAAST,IAASU,GAAQ;AACpG,YAAIA,IAASX,EAAKO,CAAC,GACfC,IAAUG,EAAO,CAAC,GAClBC,IAAOD,EAAO,CAAC,IAAI,IAAIP,GACvBK,IAAUhB,EAAImB,CAAI,GAClBF,IAAUhB,EAAIkB,CAAI,GAClBC,IAAQL,IAAUN,GAClBY,IAAOD,KAAS,IAAI,IAAI,IACxBE,IAAWD,IAAOD,GAClBG,IAAeD,IAAWE,GAC1BC,IAAIb,IAAUI;AAOlB,YALAxB,EAAI,IAAIkC,EAAMD,IAAIJ,IAAOrB,EAAIsB,CAAQ,GAAGT,IAAUI,IAAUQ,IAAIxB,EAAIqB,CAAQ,CAAC,CAAC,GAC9EpB,KAASqB,IAAeH,IAAQC,IAAOM,IAAMP,GAIzCG,IAAed,KAAWZ,IAASkB,KAAWlB,GAAQ;AACxD,cAAI+B,IAAMC,EAAeC,EAAUtB,CAAM,GAAGsB,EAAUZ,CAAM,CAAC;AAC7D,UAAAa,EAA0BH,CAAG;AAC7B,cAAII,IAAeH,EAAe9B,GAAQ6B,CAAG;AAC7C,UAAAG,EAA0BC,CAAY;AACtC,cAAIC,KAAUV,IAAeH,KAAS,IAAI,KAAK,KAAKc,EAAKF,EAAa,CAAC,CAAC;AACxE,WAAIlC,IAAMmC,KAAUnC,MAAQmC,MAAWL,EAAI,CAAC,KAAKA,EAAI,CAAC,QACpDzB,KAAWoB,IAAeH,KAAS,IAAI,IAAI;AAAA,QAE/C;AAAA,MACF;AAcF,UAAQlB,IAAQ,CAACiC,KAAWjC,IAAQiC,KAAW3C,IAAM,CAAC2C,KAAYhC,IAAU;AAC9E;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es237.js","sources":["../node_modules/underscore/modules/_isBufferLike.js"],"sourcesContent":["import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getByteLength from './_getByteLength.js';\n\n// Internal helper to determine whether we should spend extensive checks against\n// `ArrayBuffer` et al.\nexport default createSizePropertyCheck(getByteLength);\n"],"names":["isBufferLike","createSizePropertyCheck","getByteLength"],"mappings":";;AAKA,MAAAA,IAAeC,EAAwBC,CAAa;","x_google_ignoreList":[0]}

package/dist/index.es238.js

@@ -1,3 +1,6 @@
-import r from "./index.es252.js";
-r();
+import t from "./index.es277.js";
+const o = t("length");
+export {
+  o as default
+};
 //# sourceMappingURL=index.es238.js.map

package/dist/index.es238.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es238.js","sources":["../../../node_modules/d3-geo/src/length.js"],"sourcesContent":["import adder from \"./adder\";\nimport {abs, atan2, cos, radians, sin, sqrt} from \"./math\";\nimport noop from \"./noop\";\nimport stream from \"./stream\";\n\nvar lengthSum = adder(),\n    lambda0,\n    sinPhi0,\n    cosPhi0;\n\nvar lengthStream = {\n  sphere: noop,\n  point: noop,\n  lineStart: lengthLineStart,\n  lineEnd: noop,\n  polygonStart: noop,\n  polygonEnd: noop\n};\n\nfunction lengthLineStart() {\n  lengthStream.point = lengthPointFirst;\n  lengthStream.lineEnd = lengthLineEnd;\n}\n\nfunction lengthLineEnd() {\n  lengthStream.point = lengthStream.lineEnd = noop;\n}\n\nfunction lengthPointFirst(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  lambda0 = lambda, sinPhi0 = sin(phi), cosPhi0 = cos(phi);\n  lengthStream.point = lengthPoint;\n}\n\nfunction lengthPoint(lambda, phi) {\n  lambda *= radians, phi *= radians;\n  var sinPhi = sin(phi),\n      cosPhi = cos(phi),\n      delta = abs(lambda - lambda0),\n      cosDelta = cos(delta),\n      sinDelta = sin(delta),\n      x = cosPhi * sinDelta,\n      y = cosPhi0 * sinPhi - sinPhi0 * cosPhi * cosDelta,\n      z = sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosDelta;\n  lengthSum.add(atan2(sqrt(x * x + y * y), z));\n  lambda0 = lambda, sinPhi0 = sinPhi, cosPhi0 = cosPhi;\n}\n\nexport default function(object) {\n  lengthSum.reset();\n  stream(object, lengthStream);\n  return +lengthSum;\n}\n"],"names":["adder"],"mappings":";AAKgBA,EAAA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es238.js","sources":["../node_modules/underscore/modules/_getLength.js"],"sourcesContent":["import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `length` property of an object.\nexport default shallowProperty('length');\n"],"names":["getLength","shallowProperty"],"mappings":";AAGA,MAAAA,IAAeC,EAAgB,QAAQ;","x_google_ignoreList":[0]}

package/dist/index.es239.js

@@ -1,4 +1,6 @@
-import r from "./index.es252.js";
-r();
-r();
+import t from "./index.es277.js";
+const o = t("byteLength");
+export {
+  o as default
+};
 //# sourceMappingURL=index.es239.js.map

package/dist/index.es239.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es239.js","sources":["../../../node_modules/d3-geo/src/path/area.js"],"sourcesContent":["import adder from \"../adder\";\nimport {abs} from \"../math\";\nimport noop from \"../noop\";\n\nvar areaSum = adder(),\n    areaRingSum = adder(),\n    x00,\n    y00,\n    x0,\n    y0;\n\nvar areaStream = {\n  point: noop,\n  lineStart: noop,\n  lineEnd: noop,\n  polygonStart: function() {\n    areaStream.lineStart = areaRingStart;\n    areaStream.lineEnd = areaRingEnd;\n  },\n  polygonEnd: function() {\n    areaStream.lineStart = areaStream.lineEnd = areaStream.point = noop;\n    areaSum.add(abs(areaRingSum));\n    areaRingSum.reset();\n  },\n  result: function() {\n    var area = areaSum / 2;\n    areaSum.reset();\n    return area;\n  }\n};\n\nfunction areaRingStart() {\n  areaStream.point = areaPointFirst;\n}\n\nfunction areaPointFirst(x, y) {\n  areaStream.point = areaPoint;\n  x00 = x0 = x, y00 = y0 = y;\n}\n\nfunction areaPoint(x, y) {\n  areaRingSum.add(y0 * x - x0 * y);\n  x0 = x, y0 = y;\n}\n\nfunction areaRingEnd() {\n  areaPoint(x00, y00);\n}\n\nexport default areaStream;\n"],"names":["adder"],"mappings":";AAIcA;AACIA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es239.js","sources":["../node_modules/underscore/modules/_getByteLength.js"],"sourcesContent":["import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `byteLength` property of an object.\nexport default shallowProperty('byteLength');\n"],"names":["getByteLength","shallowProperty"],"mappings":";AAGA,MAAAA,IAAeC,EAAgB,YAAY;","x_google_ignoreList":[0]}

package/dist/index.es24.js

@@ -1,5 +1,5 @@
 import { memo as r, useEffect as e } from "react";
-import { applyReactStyle as i } from "./index.es199.js";
+import { applyReactStyle as i } from "./index.es266.js";
 import { useControl as l } from "./index.es30.js";
 function m(t) {
   const o = l(({ mapLib: n }) => new n.TerrainControl(t), {

package/dist/index.es240.js

@@ -1,3 +1,12 @@
-import r from "./index.es252.js";
-r();
+import e from "./index.es239.js";
+function i(t) {
+  return new Uint8Array(
+    t.buffer || t,
+    t.byteOffset || 0,
+    e(t)
+  );
+}
+export {
+  i as default
+};
 //# sourceMappingURL=index.es240.js.map

package/dist/index.es240.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es240.js","sources":["../../../node_modules/d3-geo/src/path/measure.js"],"sourcesContent":["import adder from \"../adder\";\nimport {sqrt} from \"../math\";\nimport noop from \"../noop\";\n\nvar lengthSum = adder(),\n    lengthRing,\n    x00,\n    y00,\n    x0,\n    y0;\n\nvar lengthStream = {\n  point: noop,\n  lineStart: function() {\n    lengthStream.point = lengthPointFirst;\n  },\n  lineEnd: function() {\n    if (lengthRing) lengthPoint(x00, y00);\n    lengthStream.point = noop;\n  },\n  polygonStart: function() {\n    lengthRing = true;\n  },\n  polygonEnd: function() {\n    lengthRing = null;\n  },\n  result: function() {\n    var length = +lengthSum;\n    lengthSum.reset();\n    return length;\n  }\n};\n\nfunction lengthPointFirst(x, y) {\n  lengthStream.point = lengthPoint;\n  x00 = x0 = x, y00 = y0 = y;\n}\n\nfunction lengthPoint(x, y) {\n  x0 -= x, y0 -= y;\n  lengthSum.add(sqrt(x0 * x0 + y0 * y0));\n  x0 = x, y0 = y;\n}\n\nexport default lengthStream;\n"],"names":["adder"],"mappings":";AAIgBA,EAAA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es240.js","sources":["../node_modules/underscore/modules/_toBufferView.js"],"sourcesContent":["import getByteLength from './_getByteLength.js';\n\n// Internal function to wrap or shallow-copy an ArrayBuffer,\n// typed array or DataView to a new view, reusing the buffer.\nexport default function toBufferView(bufferSource) {\n  return new Uint8Array(\n    bufferSource.buffer || bufferSource,\n    bufferSource.byteOffset || 0,\n    getByteLength(bufferSource)\n  );\n}\n"],"names":["toBufferView","bufferSource","getByteLength"],"mappings":";AAIA,SAAwBA,EAAaC,GAAc;AACjD,SAAO,IAAI;AAAA,IACTA,EAAa,UAAUA;AAAA,IACvBA,EAAa,cAAc;AAAA,IAC3BC,EAAcD,CAAY;AAAA,EAAA;AAE9B;","x_google_ignoreList":[0]}

package/dist/index.es241.js

@@ -1,34 +1,22 @@
-function e(t) {
-  return function(n) {
-    var r = new o();
-    for (var i in t) r[i] = t[i];
-    return r.stream = n, r;
+import o from "./index.es238.js";
+import f from "./index.es38.js";
+import m from "./index.es117.js";
+function v(e) {
+  var l = o(e);
+  return function(r) {
+    if (r == null) return !1;
+    var s = m(r);
+    if (o(s)) return !1;
+    for (var a = 0; a < l; a++)
+      if (!f(r[e[a]])) return !1;
+    return e !== u || !f(r[t]);
   };
 }
-function o() {
-}
-o.prototype = {
-  constructor: o,
-  point: function(t, n) {
-    this.stream.point(t, n);
-  },
-  sphere: function() {
-    this.stream.sphere();
-  },
-  lineStart: function() {
-    this.stream.lineStart();
-  },
-  lineEnd: function() {
-    this.stream.lineEnd();
-  },
-  polygonStart: function() {
-    this.stream.polygonStart();
-  },
-  polygonEnd: function() {
-    this.stream.polygonEnd();
-  }
-};
+var t = "forEach", c = "has", n = ["clear", "delete"], i = ["get", c, "set"], d = n.concat(t, i), u = n.concat(i), M = ["add"].concat(n, t, c);
 export {
-  e as transformer
+  v as ie11fingerprint,
+  d as mapMethods,
+  M as setMethods,
+  u as weakMapMethods
 };
 //# sourceMappingURL=index.es241.js.map

package/dist/index.es241.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es241.js","sources":["../../../node_modules/d3-geo/src/transform.js"],"sourcesContent":["export default function(methods) {\n  return {\n    stream: transformer(methods)\n  };\n}\n\nexport function transformer(methods) {\n  return function(stream) {\n    var s = new TransformStream;\n    for (var key in methods) s[key] = methods[key];\n    s.stream = stream;\n    return s;\n  };\n}\n\nfunction TransformStream() {}\n\nTransformStream.prototype = {\n  constructor: TransformStream,\n  point: function(x, y) { this.stream.point(x, y); },\n  sphere: function() { this.stream.sphere(); },\n  lineStart: function() { this.stream.lineStart(); },\n  lineEnd: function() { this.stream.lineEnd(); },\n  polygonStart: function() { this.stream.polygonStart(); },\n  polygonEnd: function() { this.stream.polygonEnd(); }\n};\n"],"names":["transformer","methods","stream","s","TransformStream","key","x","y"],"mappings":"AAMO,SAASA,EAAYC,GAAS;AACnC,SAAO,SAASC,GAAQ;AACtB,QAAIC,IAAI,IAAIC,EAAA;AACZ,aAASC,KAAOJ,EAAS,CAAAE,EAAEE,CAAG,IAAIJ,EAAQI,CAAG;AAC7C,WAAAF,EAAE,SAASD,GACJC;AAAA,EACT;AACF;AAEA,SAASC,IAAkB;AAAC;AAE5BA,EAAgB,YAAY;AAAA,EAC1B,aAAaA;AAAA,EACb,OAAO,SAASE,GAAGC,GAAG;AAAE,SAAK,OAAO,MAAMD,GAAGC,CAAC;AAAA,EAAG;AAAA,EACjD,QAAQ,WAAW;AAAE,SAAK,OAAO,OAAA;AAAA,EAAU;AAAA,EAC3C,WAAW,WAAW;AAAE,SAAK,OAAO,UAAA;AAAA,EAAa;AAAA,EACjD,SAAS,WAAW;AAAE,SAAK,OAAO,QAAA;AAAA,EAAW;AAAA,EAC7C,cAAc,WAAW;AAAE,SAAK,OAAO,aAAA;AAAA,EAAgB;AAAA,EACvD,YAAY,WAAW;AAAE,SAAK,OAAO,WAAA;AAAA,EAAc;AACrD;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es241.js","sources":["../node_modules/underscore/modules/_methodFingerprint.js"],"sourcesContent":["import getLength from './_getLength.js';\nimport isFunction from './isFunction.js';\nimport allKeys from './allKeys.js';\n\n// Since the regular `Object.prototype.toString` type tests don't work for\n// some types in IE 11, we use a fingerprinting heuristic instead, based\n// on the methods. It's not great, but it's the best we got.\n// The fingerprint method lists are defined below.\nexport function ie11fingerprint(methods) {\n  var length = getLength(methods);\n  return function(obj) {\n    if (obj == null) return false;\n    // `Map`, `WeakMap` and `Set` have no enumerable keys.\n    var keys = allKeys(obj);\n    if (getLength(keys)) return false;\n    for (var i = 0; i < length; i++) {\n      if (!isFunction(obj[methods[i]])) return false;\n    }\n    // If we are testing against `WeakMap`, we need to ensure that\n    // `obj` doesn't have a `forEach` method in order to distinguish\n    // it from a regular `Map`.\n    return methods !== weakMapMethods || !isFunction(obj[forEachName]);\n  };\n}\n\n// In the interest of compact minification, we write\n// each string in the fingerprints only once.\nvar forEachName = 'forEach',\n    hasName = 'has',\n    commonInit = ['clear', 'delete'],\n    mapTail = ['get', hasName, 'set'];\n\n// `Map`, `WeakMap` and `Set` each have slightly different\n// combinations of the above sublists.\nexport var mapMethods = commonInit.concat(forEachName, mapTail),\n    weakMapMethods = commonInit.concat(mapTail),\n    setMethods = ['add'].concat(commonInit, forEachName, hasName);\n"],"names":["ie11fingerprint","methods","length","getLength","obj","keys","allKeys","i","isFunction","weakMapMethods","forEachName","hasName","commonInit","mapTail","mapMethods","setMethods"],"mappings":";;;AAQO,SAASA,EAAgBC,GAAS;AACvC,MAAIC,IAASC,EAAUF,CAAO;AAC9B,SAAO,SAASG,GAAK;AACnB,QAAIA,KAAO,KAAM,QAAO;AAExB,QAAIC,IAAOC,EAAQF,CAAG;AACtB,QAAID,EAAUE,CAAI,EAAG,QAAO;AAC5B,aAASE,IAAI,GAAGA,IAAIL,GAAQK;AAC1B,UAAI,CAACC,EAAWJ,EAAIH,EAAQM,CAAC,CAAC,CAAC,EAAG,QAAO;AAK3C,WAAON,MAAYQ,KAAkB,CAACD,EAAWJ,EAAIM,CAAW,CAAC;AAAA,EACnE;AACF;AAIA,IAAIA,IAAc,WACdC,IAAU,OACVC,IAAa,CAAC,SAAS,QAAQ,GAC/BC,IAAU,CAAC,OAAOF,GAAS,KAAK,GAIzBG,IAAaF,EAAW,OAAOF,GAAaG,CAAO,GAC1DJ,IAAiBG,EAAW,OAAOC,CAAO,GAC1CE,IAAa,CAAC,KAAK,EAAE,OAAOH,GAAYF,GAAaC,CAAO;","x_google_ignoreList":[0]}

package/dist/index.es242.js

@@ -1,16 +1,24 @@
-import { sqrt as t, asin as i } from "./index.es255.js";
-import { azimuthalInvert as a, azimuthalRaw as m } from "./index.es261.js";
-import "./index.es237.js";
-import "./index.es236.js";
-import "./index.es235.js";
-import "./index.es241.js";
-var o = m(function(r) {
-  return t(2 / (1 + r));
-});
-o.invert = a(function(r) {
-  return 2 * i(r / 2);
-});
+import { ObjProto as p, nonEnumerableProps as a } from "./index.es37.js";
+import i from "./index.es38.js";
+import f from "./index.es236.js";
+function e(n) {
+  for (var r = {}, c = n.length, o = 0; o < c; ++o) r[n[o]] = !0;
+  return {
+    contains: function(u) {
+      return r[u] === !0;
+    },
+    push: function(u) {
+      return r[u] = !0, n.push(u);
+    }
+  };
+}
+function l(n, r) {
+  r = e(r);
+  var c = a.length, o = n.constructor, u = i(o) && o.prototype || p, t = "constructor";
+  for (f(n, t) && !r.contains(t) && r.push(t); c--; )
+    t = a[c], t in n && n[t] !== u[t] && !r.contains(t) && r.push(t);
+}
 export {
-  o as azimuthalEqualAreaRaw
+  l as default
 };
 //# sourceMappingURL=index.es242.js.map

package/dist/index.es242.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es242.js","sources":["../../../node_modules/d3-geo/src/projection/azimuthalEqualArea.js"],"sourcesContent":["import {asin, sqrt} from \"../math\";\nimport {azimuthalRaw, azimuthalInvert} from \"./azimuthal\";\nimport projection from \"./index\";\n\nexport var azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {\n  return sqrt(2 / (1 + cxcy));\n});\n\nazimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) {\n  return 2 * asin(z / 2);\n});\n\nexport default function() {\n  return projection(azimuthalEqualAreaRaw)\n      .scale(124.75)\n      .clipAngle(180 - 1e-3);\n}\n"],"names":["azimuthalEqualAreaRaw","azimuthalRaw","cxcy","sqrt","azimuthalInvert","z","asin"],"mappings":";;;;;;AAIO,IAAIA,IAAwBC,EAAa,SAASC,GAAM;AAC7D,SAAOC,EAAK,KAAK,IAAID,EAAK;AAC5B,CAAC;AAEDF,EAAsB,SAASI,EAAgB,SAASC,GAAG;AACzD,SAAO,IAAIC,EAAKD,IAAI,CAAC;AACvB,CAAC;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es242.js","sources":["../node_modules/underscore/modules/_collectNonEnumProps.js"],"sourcesContent":["import { nonEnumerableProps, ObjProto } from './_setup.js';\nimport isFunction from './isFunction.js';\nimport has from './_has.js';\n\n// Internal helper to create a simple lookup structure.\n// `collectNonEnumProps` used to depend on `_.contains`, but this led to\n// circular imports. `emulatedSet` is a one-off solution that only works for\n// arrays of strings.\nfunction emulatedSet(keys) {\n  var hash = {};\n  for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;\n  return {\n    contains: function(key) { return hash[key] === true; },\n    push: function(key) {\n      hash[key] = true;\n      return keys.push(key);\n    }\n  };\n}\n\n// Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't\n// be iterated by `for key in ...` and thus missed. Extends `keys` in place if\n// needed.\nexport default function collectNonEnumProps(obj, keys) {\n  keys = emulatedSet(keys);\n  var nonEnumIdx = nonEnumerableProps.length;\n  var constructor = obj.constructor;\n  var proto = (isFunction(constructor) && constructor.prototype) || ObjProto;\n\n  // Constructor is a special case.\n  var prop = 'constructor';\n  if (has(obj, prop) && !keys.contains(prop)) keys.push(prop);\n\n  while (nonEnumIdx--) {\n    prop = nonEnumerableProps[nonEnumIdx];\n    if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {\n      keys.push(prop);\n    }\n  }\n}\n"],"names":["emulatedSet","keys","hash","l","i","key","collectNonEnumProps","obj","nonEnumIdx","nonEnumerableProps","constructor","proto","isFunction","ObjProto","prop","has"],"mappings":";;;AAQA,SAASA,EAAYC,GAAM;AAEzB,WADIC,IAAO,CAAA,GACFC,IAAIF,EAAK,QAAQG,IAAI,GAAGA,IAAID,GAAG,EAAEC,EAAG,CAAAF,EAAKD,EAAKG,CAAC,CAAC,IAAI;AAC7D,SAAO;AAAA,IACL,UAAU,SAASC,GAAK;AAAE,aAAOH,EAAKG,CAAG,MAAM;AAAA,IAAM;AAAA,IACrD,MAAM,SAASA,GAAK;AAClB,aAAAH,EAAKG,CAAG,IAAI,IACLJ,EAAK,KAAKI,CAAG;AAAA,IACtB;AAAA,EAAA;AAEJ;AAKA,SAAwBC,EAAoBC,GAAKN,GAAM;AACrD,EAAAA,IAAOD,EAAYC,CAAI;AACvB,MAAIO,IAAaC,EAAmB,QAChCC,IAAcH,EAAI,aAClBI,IAASC,EAAWF,CAAW,KAAKA,EAAY,aAAcG,GAG9DC,IAAO;AAGX,OAFIC,EAAIR,GAAKO,CAAI,KAAK,CAACb,EAAK,SAASa,CAAI,KAAGb,EAAK,KAAKa,CAAI,GAEnDN;AACL,IAAAM,IAAOL,EAAmBD,CAAU,GAChCM,KAAQP,KAAOA,EAAIO,CAAI,MAAMH,EAAMG,CAAI,KAAK,CAACb,EAAK,SAASa,CAAI,KACjEb,EAAK,KAAKa,CAAI;AAGpB;","x_google_ignoreList":[0]}

package/dist/index.es243.js

@@ -1,17 +1,16 @@
-import { acos as r, sin as a } from "./index.es255.js";
-import { azimuthalInvert as n, azimuthalRaw as o } from "./index.es261.js";
-import u from "./index.es262.js";
-var i = o(function(t) {
-  return (t = r(t)) && t / a(t);
-});
-i.invert = n(function(t) {
-  return t;
-});
-function f() {
-  return u(i).scale(79.4188).clipAngle(180 - 1e-3);
+function c(v, e) {
+  return function(r) {
+    var f = arguments.length;
+    if (e && (r = Object(r)), f < 2 || r == null) return r;
+    for (var t = 1; t < f; t++)
+      for (var u = arguments[t], g = v(u), l = g.length, n = 0; n < l; n++) {
+        var a = g[n];
+        (!e || r[a] === void 0) && (r[a] = u[a]);
+      }
+    return r;
+  };
 }
 export {
-  i as azimuthalEquidistantRaw,
-  f as default
+  c as default
 };
 //# sourceMappingURL=index.es243.js.map

package/dist/index.es243.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es243.js","sources":["../../../node_modules/d3-geo/src/projection/azimuthalEquidistant.js"],"sourcesContent":["import {acos, sin} from \"../math\";\nimport {azimuthalRaw, azimuthalInvert} from \"./azimuthal\";\nimport projection from \"./index\";\n\nexport var azimuthalEquidistantRaw = azimuthalRaw(function(c) {\n  return (c = acos(c)) && c / sin(c);\n});\n\nazimuthalEquidistantRaw.invert = azimuthalInvert(function(z) {\n  return z;\n});\n\nexport default function() {\n  return projection(azimuthalEquidistantRaw)\n      .scale(79.4188)\n      .clipAngle(180 - 1e-3);\n}\n"],"names":["azimuthalEquidistantRaw","azimuthalRaw","c","acos","sin","azimuthalInvert","z","geoAzimuthalEquidistant","projection"],"mappings":";;;AAIO,IAAIA,IAA0BC,EAAa,SAASC,GAAG;AAC5D,UAAQA,IAAIC,EAAKD,CAAC,MAAMA,IAAIE,EAAIF,CAAC;AACnC,CAAC;AAEDF,EAAwB,SAASK,EAAgB,SAASC,GAAG;AAC3D,SAAOA;AACT,CAAC;AAED,SAAAC,IAA0B;AACxB,SAAOC,EAAWR,CAAuB,EACpC,MAAM,OAAO,EACb,UAAU,MAAM,IAAI;AAC3B;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es243.js","sources":["../node_modules/underscore/modules/_createAssigner.js"],"sourcesContent":["// An internal function for creating assigner functions.\nexport default function createAssigner(keysFunc, defaults) {\n  return function(obj) {\n    var length = arguments.length;\n    if (defaults) obj = Object(obj);\n    if (length < 2 || obj == null) return obj;\n    for (var index = 1; index < length; index++) {\n      var source = arguments[index],\n          keys = keysFunc(source),\n          l = keys.length;\n      for (var i = 0; i < l; i++) {\n        var key = keys[i];\n        if (!defaults || obj[key] === void 0) obj[key] = source[key];\n      }\n    }\n    return obj;\n  };\n}\n"],"names":["createAssigner","keysFunc","defaults","obj","length","index","source","keys","i","key"],"mappings":"AACA,SAAwBA,EAAeC,GAAUC,GAAU;AACzD,SAAO,SAASC,GAAK;AACnB,QAAIC,IAAS,UAAU;AAEvB,QADIF,MAAUC,IAAM,OAAOA,CAAG,IAC1BC,IAAS,KAAKD,KAAO,KAAM,QAAOA;AACtC,aAASE,IAAQ,GAAGA,IAAQD,GAAQC;AAIlC,eAHIC,IAAS,UAAUD,CAAK,GACxBE,IAAON,EAASK,CAAM,GACtB,IAAIC,EAAK,QACJC,IAAI,GAAGA,IAAI,GAAGA,KAAK;AAC1B,YAAIC,IAAMF,EAAKC,CAAC;AAChB,SAAI,CAACN,KAAYC,EAAIM,CAAG,MAAM,YAAQN,EAAIM,CAAG,IAAIH,EAAOG,CAAG;AAAA,MAC7D;AAEF,WAAON;AAAA,EACT;AACF;","x_google_ignoreList":[0]}

package/dist/index.es244.js

@@ -1,12 +1,18 @@
-import "./index.es237.js";
-import "./index.es236.js";
-import "./index.es235.js";
-import "./index.es241.js";
-function r(t, i) {
-  return [t, i];
+import o from "./index.es95.js";
+import { nativeCreate as e } from "./index.es37.js";
+function u() {
+  return function() {
+  };
+}
+function f(r) {
+  if (!o(r)) return {};
+  if (e) return e(r);
+  var t = u();
+  t.prototype = r;
+  var n = new t();
+  return t.prototype = null, n;
 }
-r.invert = r;
 export {
-  r as equirectangularRaw
+  f as default
 };
 //# sourceMappingURL=index.es244.js.map

package/dist/index.es244.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es244.js","sources":["../../../node_modules/d3-geo/src/projection/equirectangular.js"],"sourcesContent":["import projection from \"./index\";\n\nexport function equirectangularRaw(lambda, phi) {\n  return [lambda, phi];\n}\n\nequirectangularRaw.invert = equirectangularRaw;\n\nexport default function() {\n  return projection(equirectangularRaw)\n      .scale(152.63);\n}\n"],"names":["equirectangularRaw","lambda","phi"],"mappings":";;;;AAEO,SAASA,EAAmBC,GAAQC,GAAK;AAC9C,SAAO,CAACD,GAAQC,CAAG;AACrB;AAEAF,EAAmB,SAASA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es244.js","sources":["../node_modules/underscore/modules/_baseCreate.js"],"sourcesContent":["import isObject from './isObject.js';\nimport { nativeCreate } from './_setup.js';\n\n// Create a naked function reference for surrogate-prototype-swapping.\nfunction ctor() {\n  return function(){};\n}\n\n// An internal function for creating a new object that inherits from another.\nexport default function baseCreate(prototype) {\n  if (!isObject(prototype)) return {};\n  if (nativeCreate) return nativeCreate(prototype);\n  var Ctor = ctor();\n  Ctor.prototype = prototype;\n  var result = new Ctor;\n  Ctor.prototype = null;\n  return result;\n}\n"],"names":["ctor","baseCreate","prototype","isObject","nativeCreate","Ctor","result"],"mappings":";;AAIA,SAASA,IAAO;AACd,SAAO,WAAU;AAAA,EAAC;AACpB;AAGA,SAAwBC,EAAWC,GAAW;AAC5C,MAAI,CAACC,EAASD,CAAS,UAAU,CAAA;AACjC,MAAIE,EAAc,QAAOA,EAAaF,CAAS;AAC/C,MAAIG,IAAOL,EAAA;AACX,EAAAK,EAAK,YAAYH;AACjB,MAAII,IAAS,IAAID,EAAA;AACjB,SAAAA,EAAK,YAAY,MACVC;AACT;","x_google_ignoreList":[0]}